Joseph Ferano
d6fc15474b
The author: "I think I prefer length over len, because then I'll use len as the variable name". One arm in check.ml, one row in the table beside it, and every (len x) in lib, test, examples, vendor, spike, docs, web, emacs, plan.org and NEXT.md rewritten. Shadowing and builtin/ had already taken most of the sting out: a (defn len ...) was legal and won in its own file, and builtin/len reached past it. What was left is that len was still a builtin — the defn earned a warning, and a wrapper had to say builtin/ at every inner call. Now there is nothing under the short name: len is an ordinary identifier in every position, which is what (let [len (length xs)] ...) wants. length takes over as shadowing's worked example rather than the feature losing one. shadow-builtin.flan, builtin-qualified.flan, pkgs/shadowed and the builtin/ rows in test_flan move to it and go on testing shadowing. A call to a len nothing defines is answered where an unknown function is, after every table and after the shadowing guard, so a program with its own len never reaches it. The sentence is said rather than guessed at — len and length are three edits apart and the did-you-mean's net is one — and the call is written back out through spell_arg, as-slice's spelling lifted out of it and now shared, so what is printed compiles. sand.flan:33 still calls the old name and is the author's to change; until it does, test_acceptance and test_session abort there. Both were run green against a copy with that one line changed. FIX.org says so.
59 lines
2.8 KiB
Plaintext
59 lines
2.8 KiB
Plaintext
;;;; Assets baked in at compile time — NEXT.md decision 1.
|
|
;;;;
|
|
;;;; Odin's #load and #load_directory are the model, spelled as ordinary named
|
|
;;;; calls because an s-expression language already has a head position and
|
|
;;;; does not need Odin's `#`. The whole reason for preferring this to a build
|
|
;;;; flag is that it is a *compiler* feature: no linker arguments, no
|
|
;;;; per-target packaging, and identical on desktop and web. A single-file
|
|
;;;; program has no link channel at all — `Load` hands out lflags only to a
|
|
;;;; directory package — so the file that needs the asset is structurally the
|
|
;;;; one file that could not declare it. Embedding has no such hole.
|
|
;;;;
|
|
;;;; Nothing here costs anything at run time: every one of these is a
|
|
;;;; `private unnamed_addr constant` in the emitted module.
|
|
|
|
;; Bound once at top level, where it becomes an LLVM constant outright rather
|
|
;; than an array rebuilt on the stack per call (emit.ml's `const`).
|
|
(defconst assets [3 EmbedFile] (embed-dir "assets"))
|
|
|
|
(defn main [] i32
|
|
;; The default answer is a [u8]: bytes, because that is what an asset is.
|
|
(let [a (embed "assets/a.txt")]
|
|
(println (length a)) ; 13
|
|
(print (string a))) ; hello from a
|
|
|
|
;; `string` is the second spelling, not a different meaning for the same
|
|
;; text. With structural equality and nothing that converts one container
|
|
;; into another -- implicit widening is numbers only -- one form that changes
|
|
;; type with its context would be a wart.
|
|
(println (embed "assets/b.bin" string)) ; BBB
|
|
|
|
;; Byte-exact, including bytes no text encoding would survive: emit.ml's
|
|
;; escape hex-escapes everything outside printable ASCII, so a PNG makes the
|
|
;; round trip through the .ll unchanged.
|
|
(let [raw (embed "assets/raw.bin")]
|
|
(println (length raw)) ; 4
|
|
(println (at raw 0)) ; 0
|
|
(println (at raw 2)) ; 255
|
|
(println (at raw 3))) ; 254
|
|
|
|
;; A directory embed is a fixed array of EmbedFile, sorted by name — sorted
|
|
;; because readdir order is filesystem-dependent and an unsorted embed would
|
|
;; make two builds of identical sources emit different .ll.
|
|
(println (length assets)) ; 3
|
|
(println (.name (at assets 0))) ; a.txt
|
|
(println (.name (at assets 1))) ; b.bin
|
|
(println (.name (at assets 2))) ; raw.bin
|
|
|
|
;; The name-to-bytes lookup is a linear scan in the prelude. It takes a slice
|
|
;; rather than the array, because an array's length is part of its type and
|
|
;; there are no generics.
|
|
(let [all (slice assets 0 (length assets))]
|
|
(match (embed-find all "b.bin")
|
|
(Some b) (println (string b)) ; BBB
|
|
None (println "missing"))
|
|
(match (embed-find all "nope.txt")
|
|
(Some _) (println "found")
|
|
None (println "no nope.txt"))) ; no nope.txt
|
|
0)
|