Joseph Ferano
1ee54d6b56
The prelude's own (vec-new Form) was refused with "nothing here says what (vec-new) is a Vec of" -- a message about a missing annotation, to a program that had written one. The build went red the moment the Form declaration was checked against anything, which is why the front half landed unmeasured. The test a leading bare symbol has to pass was spelled out twice, once in vec_new_elem and once in map_new_types, and both lists were written before unions existed: primitives, structs, enums, aliases. resolve_name has known about unions since they landed, so the two halves disagreed about what a type name is. Now there is one list, read by both, so the next kind of type cannot be added to one of them. The case is in unions.flan rather than in a file of its own, because what it asserts is that a union is an element type like any other -- (vec-new Shape), (map-new string Shape) -- and that is a sentence about unions. Also drops forms.so, a build artefact the last lane committed.
111 lines
4.4 KiB
Plaintext
111 lines
4.4 KiB
Plaintext
;;;; Union values: declaring one, making one, matching one, printing one.
|
|
;;;;
|
|
;;;; The layout claim is the load-bearing one, so it is asserted rather than
|
|
;;;; described: a union is a tag and room for the largest case, aligned to the
|
|
;;;; widest member of any case, which is C's struct { int tag; union {...}; }.
|
|
;;;; That is what the macro expander will need to agree with byte for byte, so
|
|
;;;; `Shape` here is deliberately the shape a Form has: a case with no fields,
|
|
;;;; a case whose members are wider than another's, and a case holding a
|
|
;;;; string -- the three things a payload blob has to hold without disturbing
|
|
;;;; the alignment of any of them.
|
|
|
|
(defunion Shape
|
|
[Empty
|
|
(Dot [x f64 y f64])
|
|
(Rect [w i32 h i32])
|
|
(Tag [name string n u8])])
|
|
|
|
;; A union crosses a call boundary in both directions, as a parameter and as a
|
|
;; return type -- a value that cannot do that is not a value.
|
|
(defn area [s Shape] f64
|
|
(match s
|
|
(Rect w h) (* (f64 w) (f64 h))
|
|
(Dot _x _y) 0.0
|
|
_ -1.0))
|
|
|
|
(defn widen [n i32] Shape (Shape.Rect {.w n .h (* n 2)}))
|
|
|
|
;; A union as a struct field, which is the path that makes its size and
|
|
;; alignment visible to something other than a slot.
|
|
(defstruct Cell [id i32 s Shape])
|
|
|
|
(defn describe [s Shape] string
|
|
(match s
|
|
Empty "empty"
|
|
(Dot x y) (if (= x y) "dot on the diagonal" "dot")
|
|
(Rect w h) (if (= w h) "square" "rect")
|
|
(Tag name n) name))
|
|
|
|
;; A union that names itself through a pointer. check_finite refuses one that
|
|
;; contains itself by value -- the emitter would recurse forever laying it out
|
|
;; -- and this is the shape that works instead.
|
|
(defunion Tree [Leaf (Node [l (Ptr Tree) n i32])])
|
|
|
|
(defn depth [t (Ptr Tree)] i32
|
|
(match (deref t)
|
|
Leaf 0
|
|
(Node l n) (+ n (depth l))))
|
|
|
|
(defn main [] i32
|
|
;; A case with no fields is a whole value and is written as a name.
|
|
(println (describe Shape.Empty))
|
|
(println (describe (Shape.Dot {.x 2.0 .y 2.0})))
|
|
(println (describe (Shape.Dot {.x 1.0 .y 2.0})))
|
|
(println (describe (Shape.Rect {.w 3 .h 3})))
|
|
(println (describe (Shape.Tag {.name "tagged" .n 7})))
|
|
|
|
;; ZII: omitted fields are zeroed, exactly as in a struct literal.
|
|
(println (describe (Shape.Rect {.w 0})))
|
|
|
|
;; Returned from a call, then matched.
|
|
(print (i64 (area (widen 4)))) (println "")
|
|
(print (i64 (area (Shape.Dot {.x 9.0 .y 9.0})))) (println "")
|
|
(print (i64 (area Shape.Empty))) (println "")
|
|
|
|
;; Through a struct field, and copied: assigning a Cell copies the union's
|
|
;; bytes, so the copy's payload must be the original's.
|
|
(let [c (Cell {.id 1 .s (Shape.Tag {.name "in a cell" .n 3})})
|
|
d c]
|
|
(println (describe (.s d)))
|
|
;; A zeroed union is the first declared case -- Empty -- which is what
|
|
;; makes case order part of the contract.
|
|
(let [z (Cell {.id 2})]
|
|
(println (describe (.s z)))))
|
|
|
|
;; A local assigned a second case: the tag moves and the payload is rewritten.
|
|
(let [v Shape.Empty]
|
|
(set v (Shape.Rect {.w 5 .h 6}))
|
|
(print (i64 (area v))) (println "")
|
|
(set v (Shape.Tag {.name "reassigned" .n 1}))
|
|
(println (describe v)))
|
|
|
|
;; Recursive through a pointer, which is the shape a Form has: a union that
|
|
;; contains itself by value has no size and is refused, and (Ptr T) is what
|
|
;; breaks the cycle. 5 + 10 + 0.
|
|
(let [leaf Tree.Leaf
|
|
mid (Tree.Node {.l (addr leaf) .n 10})
|
|
top (Tree.Node {.l (addr mid) .n 5})]
|
|
(print (depth (addr top))) (println ""))
|
|
|
|
;; The structural printer, which reads only the case in hand: the other
|
|
;; cases' fields are not there to read.
|
|
(print Shape.Empty) (println "")
|
|
(print (Shape.Dot {.x 1.5 .y -2.5})) (println "")
|
|
(print (Shape.Tag {.name "printed" .n 9})) (println "")
|
|
(print (Cell {.id 7 .s (Shape.Rect {.w 1 .h 2})})) (println "")
|
|
|
|
;; A union names an element type the same way a struct does. It reads as
|
|
;; trivia and it was not: the type-name test (vec-new) and (map-new) use to
|
|
;; read a leading bare symbol listed structs, enums, aliases and primitives
|
|
;; and not unions, so (vec-new Shape) was refused for not saying what it
|
|
;; held -- by a program that had said.
|
|
(let [vs (vec-new Shape)
|
|
ms (map-new string Shape)]
|
|
(push vs (Shape.Rect {.w 2 .h 3}))
|
|
(push vs Shape.Empty)
|
|
(put ms "only" (Shape.Tag {.name "in a map" .n 1}))
|
|
(print (i64 (area (at vs 0)))) (println "")
|
|
(println (describe (at vs 1)))
|
|
(println (match (get ms "only") (Some s) (describe s) None "missing")))
|
|
0)
|