e04834f | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

e04834f — Peter John 2026-11-03T18:37:07+05:30

Unboxed variants, enum init, List -> Slice, std cons List

Files changed (91) hide show

README.md +107 -41
docs/plans/2026-11-03-unboxed-variants.benchmark.md +23 -0
docs/plans/2026-11-03-unboxed-variants.md +174 -0
docs/plans/2026-11-03-unboxed-variants.progress.md +41 -0
docs/plans/2026-11-03-unboxed-variants.report.json +363 -0
docs/plans/2026-11-03-unboxed-variants.report.md +53 -0
docs/plans/2026-11-03-unboxed-variants.review.md +69 -0
plum-checker/src/lib.rs +17 -4
plum-checker/src/ownership.rs +2 -2
plum-checker/tests/checker_tests.rs +16 -16
plum-checker/tests/inline_variants_tests.rs +1 -1
plum-checker/tests/ownership_flow_test.rs +16 -8
plum-checker/tests/ownership_moves_test.rs +1 -1
plum-checker/tests/types_tests.rs +5 -5
plum-checker/tests/unions_tests.rs +1 -1
plum-core/src/forms.rs +11 -5
plum-core/src/loader.rs +1 -1
plum-core/tests/formatter_test.rs +8 -8
plum-core/tests/inline_variants_test.rs +1 -1
plum-core/tests/parser_test.rs +7 -7
plum-core/tests/record_init_test.rs +2 -2
plum-core/tests/traits_test.rs +2 -2
plum-core/tests/trmc_test.rs +3 -3
plum-core/tests/union_lower_test.rs +1 -1
plum-core/tests/unions_test.rs +2 -2
plum-examples/annotated_locals.plum +2 -2
plum-examples/cons_list.plum +70 -0
plum-examples/constants.plum +2 -2
plum-examples/error_propagation.plum +17 -17
plum-examples/forms.plum +16 -16
plum-examples/functional.plum +91 -90
plum-examples/game.plum +4 -4
plum-examples/game_loop.plum +6 -6
plum-examples/game_pure_scene.plum +20 -20
plum-examples/game_scene.plum +6 -6
plum-examples/game_state_view.plum +50 -51
plum-examples/generics.plum +21 -21
plum-examples/json.plum +7 -7
plum-examples/loops.plum +10 -10
plum-examples/optionals.plum +5 -5
plum-examples/own_list.plum +5 -5
plum-examples/scene.plum +7 -7
plum-examples/seq.plum +19 -19
plum-examples/strings.plum +2 -2
plum-examples/struct_arrays.plum +8 -8
plum-examples/struct_union_members.plum +4 -4
plum-examples/structs_records.plum +1 -1
plum-examples/tail_calls.plum +6 -6
plum-examples/trait_scene.plum +4 -4
plum-examples/traits.plum +2 -2
plum-examples/unboxed_variants.plum +337 -0
plum-examples/unions.plum +13 -13
plum-game/web-test/fixtures/stress_pure_scene.plum +8 -8
plum-game/web-test/fixtures/stress_scene.plum +1 -1
plum-game/web-test/fixtures/stress_state_view.plum +17 -17
plum-game/web-test/fixtures/stress_state_view_deep.plum +25 -25
plum-game/web-test/fixtures/stress_world.plum +1 -1
plum-lsp/src/main.rs +4 -4
plum-std/Array.plum +2 -2
plum-std/Deque.plum +1 -1
plum-std/Heap.plum +4 -4
plum-std/Http.plum +1 -1
plum-std/Json.plum +30 -30
plum-std/List.plum +136 -0
plum-std/Map.plum +1 -1
plum-std/Os.plum +3 -3
plum-std/Seq.plum +16 -16
plum-std/Set.plum +3 -3
plum-std/Slice.plum +44 -44
plum-std/Str.plum +5 -5
plum-std/Testing.plum +16 -16
plum-std/game/Actions.plum +16 -16
plum-std/game/Picture.plum +25 -25
plum-std/game/PureScene.plum +16 -16
plum-std/game/Scene.plum +10 -10
plum-std/game/SceneInput.plum +18 -18
plum-std/game/SceneTree.plum +32 -32
plum-wasm-codegen/src/lib.rs +137 -3
plum-wasm-codegen/tests/codegen_tests.rs +41 -41
plum-wasm-codegen/tests/enum_init_e2e_test.rs +148 -0
plum-wasm-codegen/tests/examples_test.rs +3 -3
plum-wasm-codegen/tests/inline_variants_e2e_test.rs +1 -1
plum-wasm-codegen/tests/loop_break_e2e_test.rs +1 -1
plum-wasm-codegen/tests/own_inplace_e2e_test.rs +1 -1
plum-wasm-codegen/tests/record_embed_e2e_test.rs +1 -1
plum-wasm-codegen/tests/record_init_e2e_test.rs +3 -3
plum-wasm-codegen/tests/tail_calls_e2e_test.rs +1 -1
plum-wasm-codegen/tests/traits_e2e_test.rs +11 -11
plum-wasm-codegen/tests/type_param_static_test.rs +6 -6
plum-wasm-codegen/tests/unboxed_variants_e2e_test.rs +252 -0
plum-wasm-codegen/tests/unions_e2e_test.rs +5 -5

README.md CHANGED Viewed

@@ -13,7 +13,7 @@ import std/Os
 import std/Str
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 import std/Seq
 error ParseError = BadNum | Negative       # a named error set
@@ -48,7 +48,7 @@ fun double(s: Str) -> error{BadNum, Negative}!Int =
   n := try parse(s)                        # `try` propagates the error
   n * 2
-fun firstEven(xs: List[Int]) -> Int? =     # `T?` is a T or null
+fun firstEven(xs: Slice[Int]) -> Int? =     # `T?` is a T or null
   for x := range xs.find()                 # a Seq terminal; the body is the predicate
     x % 2 == 0
@@ -56,9 +56,9 @@ fun main() =
   total := 0
   for i := range 10, if i % 2 == 0         # range, with a `, if` filter clause
     total = total + i
-  big := for x := range List(1, 5, 9).map(), if x > 2
+  big := for x := range Slice(1, 5, 9).map(), if x > 2
     x * 10                                 # the body is the mapped value
-  e := firstEven(List(1, 3, 4)) ?: -1      # `?:` supplies a default for null
+  e := firstEven(Slice(1, 3, 4)) ?: -1      # `?:` supplies a default for null
   n := parse("42") catch 0                 # `catch` supplies a default for an error
   pos := Vec2.Zero + Vec2(x: 1.0, y: 2.0)
   printLn("{total} {big.length()} {e} {n} {pos.y} {Shape.SidesMax}")
@@ -67,7 +67,7 @@ test "glance"
   assert Rect(w: 2.0, h: 3.0).area() == 6.0
   assert {double("21") catch 0} == 42
   assert {parse("-1") catch 7} == 7
-  assert firstEven(List(1, 3)) == null
+  assert firstEven(Slice(1, 3)) == null
 ```
 | You want | Write |
@@ -99,7 +99,7 @@ Discarding the result of a call is a compile error, so `scores.push(3)` on a typ
 ```plum
 fun main() =
-  list := List(1, 2, 3)
+  list := Slice(1, 2, 3)
   _ := list.pop()!      # evaluate, drop the removed element
   list.push(4)          # fine: push returns Unit
 ```
@@ -193,7 +193,7 @@ module basics
 import std/Os
 ```
-Nothing is implicit: `Int`, `Float`, `Str`, `List`, ... are available once the file imports `std/Int`, `std/Float`, `std/Str`, `std/List`, ...
+Nothing is implicit: `Int`, `Float`, `Str`, `Slice`, ... are available once the file imports `std/Int`, `std/Float`, `std/Str`, `std/Slice`, ...
 ## Literals
@@ -297,7 +297,7 @@ x = 2
 ```plum
 s: Shape := Circle(r: 2.0)
-xs: List[Shape] := List[Shape]()
+xs: Slice[Shape] := Slice[Shape]()
 o: Int? := null
 s = Rect(w: 1.0, h: 2.0)       # checked, and converted, against Shape
 ```
@@ -449,11 +449,11 @@ u2 := u
 u2.age = 4         # u.age is now 4: a record is a heap object, shared on assignment
 ```
-A `struct` has no generics; its fields are only `Int`, `Float`, `Bool`, `Byte` or other structs, and a struct can't contain itself. Values are copied on assignment and when passed, and are boxed inside `T?` and other generic slots. Arrays of structs (`Array[Vec2]`, and so `List[Vec2]` and `Grid[Tile]`) are stored field by field, one native array per field, with no per-element allocation. A `record` may have any field types and may be generic (`record Pair[K, V](key: K, val: V)`). Methods and `match` work as for any enum. See [`plum-examples/structs_records.plum`](plum-examples/structs_records.plum).
+A `struct` has no generics; its fields are only `Int`, `Float`, `Bool`, `Byte` or other structs, and a struct can't contain itself. Values are copied on assignment and when passed, and are boxed inside `T?` and other generic slots. Arrays of structs (`Array[Vec2]`, and so `Slice[Vec2]` and `Grid[Tile]`) are stored field by field, one native array per field, with no per-element allocation. A `record` may have any field types and may be generic (`record Pair[K, V](key: K, val: V)`). Methods and `match` work as for any enum. See [`plum-examples/structs_records.plum`](plum-examples/structs_records.plum).
 ### Enums
-An `enum` lists the types it can hold. A member is a declared `struct` or `record`, a built-in (`Int`, `Float`, `Bool`, `Byte`), a std type (`Str`, `List[Json]`, `Map[Str, Json]`), or a bare name that is not a declared type, which becomes a payload-less tag. A short list fits on one line; a longer one, or one with methods, goes on indented `|` lines. Every member other than a tag is an existing type, and the enum adds no new constructor for it:
+An `enum` lists the types it can hold. A member is a declared `struct` or `record`, a built-in (`Int`, `Float`, `Bool`, `Byte`), a std type (`Str`, `Slice[Json]`, `Map[Str, Json]`), or a bare name that is not a declared type, which becomes a payload-less tag. A short list fits on one line; a longer one, or one with methods, goes on indented `|` lines. Every member other than a tag is an existing type, and the enum adds no new constructor for it:
 ```plum
 struct Circle(r: Float) =
@@ -476,7 +476,7 @@ enum Json =
   | Bool
   | Float
   | Str
-  | List[Json]
+  | Slice[Json]
   | Map[Str, Json]
 ```
@@ -505,7 +505,7 @@ fun show(j: Json) -> Str =
     Bool => if j then "true" else "false"
     Float => j.toStr()
     Str => "\"{j}\""
-    List => "list"
+    Slice => "list"
     Map => "map"
 ```
@@ -585,7 +585,7 @@ record House(Entity(pos, z), Clickable(hits), kind: Int) =
 ```
 ```plum
-es := List[Entity]()
+es := Slice[Entity]()
 es.push(House(pos: p, z: 0, hits: 0, kind: 1))   # House converts to Entity
 for e := range es
   e.update(dt)                      # runs House.update
@@ -638,7 +638,7 @@ An `own record` (or `own trait`) is a value with a single owner, so the compiler
 ```plum
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 own record Cell(x: Float) =
   fun step(own self) -> Cell = Cell(..self, x: self.x + 1.0)
@@ -662,7 +662,7 @@ test "own"
   w := World(cell: Cell(x: 0.0))
   advance(w)
   assert {w.cell.x - 1.0}.abs() < 1e-6
-  xs := List(Cell(x: 1.0), Cell(x: 2.0))
+  xs := Slice(Cell(x: 1.0), Cell(x: 2.0))
   ys := xs.mapInPlace(|k| Cell(..k, x: k.x + 1.0))
   assert {ys.at(1).x - 3.0}.abs() < 1e-6
 ```
@@ -670,7 +670,7 @@ test "own"
 - **What moves:** passing a value to an `own` parameter, calling an `own self` method, returning it, storing it in a field or list, and `match`ing on an owned value (the match consumes it). **What borrows:** plain parameters and plain `self`, and reads such as `s.x`.
 - **Spread writes in place:** `Cell(..s, x: s.x + 1.0)` where `s` is owned reuses `s`'s storage and writes the changed fields into it, so no new record is allocated. Spreading a borrowed or ordinary record still copies.
 - **Swap form:** you can't move a field out of a record, so replace it with a method call that takes and returns it: `w.cell = w.cell.step()` (in a game, `w.stage = w.stage.frame(dt, inputs).intoStage()`).
-- **Lists:** `List.mapInPlace` rewrites every element, and `takeAt(i)` / `putAt(i, v)` move one element out and back. See [`plum-examples/own_list.plum`](plum-examples/own_list.plum).
+- **Slices:** `Slice.mapInPlace` rewrites every element, and `takeAt(i)` / `putAt(i, v)` move one element out and back. See [`plum-examples/own_list.plum`](plum-examples/own_list.plum).
 The ownership checker reports mistakes at compile time:
@@ -731,7 +731,7 @@ A `struct`'s constructor takes all its fields. A `record`'s header is its constr
 record Bag(n: Int) =
   fun init(self) =
     self.label = "bag"
-    self.items: List[Int] = List[Int]()
+    self.items: Slice[Int] = Slice[Int]()
     self.cap: Int = self.n * 2
 ```
@@ -764,6 +764,72 @@ match book
 Patterns can be literals, a bare identifier (binds), a bare capitalized name (a member or tag of an enum, or an error name when matching an error value, also written `error.Name`; compared), a constructor pattern (`Circle(r)`, binding its fields, possibly nested), a bare member name (`Float`, which narrows the subject to that type, see [Enums](#enums)), or `_` (wildcard). `match a, b, ...` supports multiple subjects, and a case can carry a `when <expr>` guard. A `match` over an enum must be exhaustive. See [`plum-examples/match.plum`](plum-examples/match.plum).
+### Enum `init`
+`TypeName(args)` on an enum calls its static `init`, the same call syntax as a record. The result is any member of the enum. This is how `List(1, 2, 3)` builds a cons list:
+```plum
+module shapes
+import std/Int
+import std/Str
+enum Shape =
+  | Dot
+  | Line(len: Int)
+  fun init(n: Int) -> Shape = if n == 0 then Dot else Line(len: n)
+  fun size(self) -> Int = match self
+    Dot => 0
+    Line(len) => len
+test "enum init"
+  assert Shape(0).size() == 0
+  assert Shape(7).size() == 7
+```
+## Lists, slices and arrays
+Three sequence types, from `std/List`, `std/Slice` and `std/Array`.
+**`List[T]`** is the std cons list: `Nil` or `Cons(head, tail)`. It is the default for recursive code, with pattern matching and `List(1, 2, 3)` (an enum `init`). Each cell is one allocation. Self tail calls run as loops and a constructor-wrapped self call (`map`) is rewritten to a loop (tail modulo cons), so recursion over a million cells uses constant stack. `for x := range xs` works, but `at(i)` is O(i), so a plain index loop is quadratic.
+```plum
+module lists
+import std/Int
+import std/Str
+import std/List
+fun sum(xs: List[Int], acc: Int) -> Int = match xs
+  Nil => acc
+  Cons(h, t) => sum(t, acc + h)
+test "list"
+  xs := List(1, 2, 3, 4)
+  assert sum(xs, 0) == 10
+  assert xs.map(|x| x * 2).length() == 4
+  total := 0
+  for x := range xs
+    total = total + x
+  assert total == 10
+```
+**`Slice[T]`** is the growable view over an `Array` (the type formerly called `List`): indexed access, `push`, `Slice(1, 2, 3)`.
+```plum
+module slices
+import std/Int
+import std/Slice
+test "slice"
+  s := Slice(1, 2, 3)
+  s.push(4)
+  assert s.length() == 4
+  assert s.at(3) == 4
+```
+**`Array[T]`** is the fixed-length array, unchanged: arrays of structs are stored field by field. See [`plum-examples/struct_arrays.plum`](plum-examples/struct_arrays.plum).
 ## Generics
 ```plum
@@ -779,7 +845,7 @@ A generic call whose type parameters stay unknown is an error at the call, befor
 ### How generics compile
-Generics are duck-typed and compiled per type, as in Zig. A generic body is type-checked once per concrete instantiation, and each instantiation gets its own compiled copy with unboxed values (an array of its own element type, no boxing at generic edges): `List[Int]` and `List[Str]` are different code, and a `List[Float]` stores raw `f64`s.
+Generics are duck-typed and compiled per type, as in Zig. A generic body is type-checked once per concrete instantiation, and each instantiation gets its own compiled copy with unboxed values (an array of its own element type, no boxing at generic edges): `Slice[Int]` and `Slice[Str]` are different code, and a `Slice[Float]` stores raw `f64`s.
 - **No bounds.** `[T]` carries no constraint. `fun show(x: T) -> Str = x.toStr()` works for every type that has a `toStr` method and fails at the use site otherwise.
 - **Errors point at the use site.** A missing method is reported against the concrete type, with the chain of instantiations that led there:
@@ -797,7 +863,7 @@ in outer[Plain] (called at main.plum:9:3):
 ```plum
 record Num[T](add: fn(T, T) -> T, zero: T)
-fun sumWith(xs: List[T], num: Num[T]) -> T =
+fun sumWith(xs: Slice[T], num: Num[T]) -> T =
   acc := num.zero
   for x := range xs
     acc = num.add(acc, x)
@@ -807,15 +873,15 @@ fun sumWith(xs: List[T], num: Num[T]) -> T =
 ```plum
 intNum := Num(add: |a, b| a + b, zero: 0)
 floatNum := Num(add: |a, b| a + b, zero: 0.0)
-sumWith(List(1, 2, 3), intNum)      # 6
+sumWith(Slice(1, 2, 3), intNum)      # 6
-sumWith(List(1.5, 2.5), floatNum)   # 4.0
+sumWith(Slice(1.5, 2.5), floatNum)   # 4.0
 ```
   `num.add(a, b)` calls the closure stored in the fn-typed field `add`; if the type also declares a method named `add`, the method wins. See `num_record_passed_explicitly` in [`plum-examples/generics.plum`](plum-examples/generics.plum).
 ## Constants, statics and `primitive`
-There are no top-level constants and no free-standing statics. A constant lives inside a type's body (`enum`, `struct`, `record`) or a `primitive`; `Name = expr` declares an associated constant, and a `fun` without `self` is a static function. A constant's name is PascalCase, at least two characters, with no underscores and no two capitals in a row (`MaxRetries`, `Ln2`, `Log10E`). A constant is always read as `Type.Name`, from anywhere including inside the same body; a static is called as `Type.f(args)`, or by its bare name inside the same body. A constant is evaluated lazily, once (a heap value such as a `List` is cached and shared), and names are unique per type, so `Alpha.Flag` and `Beta.Flag` coexist. A constant may not share its name with a variant of its own type.
+There are no top-level constants and no free-standing statics. A constant lives inside a type's body (`enum`, `struct`, `record`) or a `primitive`; `Name = expr` declares an associated constant, and a `fun` without `self` is a static function. A constant's name is PascalCase, at least two characters, with no underscores and no two capitals in a row (`MaxRetries`, `Ln2`, `Log10E`). A constant is always read as `Type.Name`, from anywhere including inside the same body; a static is called as `Type.f(args)`, or by its bare name inside the same body. A constant is evaluated lazily, once (a heap value such as a `Slice` is cached and shared), and names are unique per type, so `Alpha.Flag` and `Beta.Flag` coexist. A constant may not share its name with a variant of its own type.
 ```plum
 enum Level =
@@ -879,7 +945,7 @@ fun main() -> Int =
   each(|v| v * 3) + useCapturingClosure()
 ```
-A closure literal is `|params| body`. Capture is snapshot-by-value: a closure copies the outer variables it references at creation time, not re-read live later. A `fn(...) -> T` type annotates a closure-typed parameter or field, and a named function can be passed wherever a `fn` value is expected. `List` and `Map` have no closure-taking iteration methods (use `for`, below); closures are for passing behavior around as values (see `Num` under [Generics](#how-generics-compile)). See [`plum-examples/closures.plum`](plum-examples/closures.plum).
+A closure literal is `|params| body`. Capture is snapshot-by-value: a closure copies the outer variables it references at creation time, not re-read live later. A `fn(...) -> T` type annotates a closure-typed parameter or field, and a named function can be passed wherever a `fn` value is expected. `Slice` and `Map` have no closure-taking iteration methods (use `for`, below); closures are for passing behavior around as values (see `Num` under [Generics](#how-generics-compile)). See [`plum-examples/closures.plum`](plum-examples/closures.plum).
 A closure parameter may carry a type, `|b: Box| b.get()`, and then it has that type (a mismatch with an expected `fn(..)` is a type error). An untyped closure stored in a local takes its parameter types from the first call of that local; if there is none, the error is `cannot infer the type of b; write |b: Box|`.
@@ -932,7 +998,7 @@ Beyond `range n` (0 to n-1), the `Int` methods `a.until(b)` (a to b-1), `a.to(b)
 The protocol is resolved on the type of the source, after type inference:
-- one binder: the type has `length()` and `at(i)` (a `List`, `Array`, `Deque`, a variadic parameter, your own type);
+- one binder: the type has `length()` and `at(i)` (a `Slice`, `Array`, `Deque`, a variadic parameter, your own type);
 - two binders: if the type declares a `fun* entries(self) *(A, B)` method it is used (`Map` does: `(key, value)`), otherwise `(position, element)` over `length()`/`at(i)`;
 - `x.name(args)` where the type of `x` declares `fun* name(self, ..)`: the method is expanded like any `fun*`, with `self` bound to `x`.
@@ -971,8 +1037,8 @@ fun* neighbours(x: Int, y: Int) *(Int, Int) =
 `Seq[T]` is a compiler primitive and `*T` is sugar for it. A `Seq` never exists at runtime: it can't be stored, returned or captured, it only flows into a `for` source or into the next method call. The methods live in [`plum-std/Seq.plum`](plum-std/Seq.plum) under `primitive Seq[T]`; `xs.m()` where the type of `xs` has no `m` of its own and is iterable (`length()`/`at(i)`, or an `entries()` method) resolves to `Seq.m`, so they work on every list-like type:
-- **adapters** reshape a sequence, have no result and may appear anywhere in a chain: `take(n)`, `skip(n)`, `stepBy(n)`, `zip(other)`, `reversed()`, `chunks(n)` (the last three need a `List` receiver);
-- **terminals** take the `for` body (the predicate, the mapping, the step) and must be the last call: `filter()` (`-> List[T]`), `map()` (`-> List[U]`), `find()` (`-> T?`), `fold(init)` (binders `acc, x`), `count()`, `any()`, `all()`, `each()`, `firstN(n)` (the first n elements the body accepts), and `toList()`, which has no body and needs no `for`: `ys := xs.skip(1).take(3).toList()`.
+- **adapters** reshape a sequence, have no result and may appear anywhere in a chain: `take(n)`, `skip(n)`, `stepBy(n)`, `zip(other)`, `reversed()`, `chunks(n)` (the last three need a `Slice` receiver);
+- **terminals** take the `for` body (the predicate, the mapping, the step) and must be the last call: `filter()` (`-> Slice[T]`), `map()` (`-> Slice[U]`), `find()` (`-> T?`), `fold(init)` (binders `acc, x`), `count()`, `any()`, `all()`, `each()`, `firstN(n)` (the first n elements the body accepts), and `toList()`, which has no body and needs no `for`: `ys := xs.skip(1).take(3).toList()`.
 A terminal in the middle of a chain is an error (`'filter' needs the for body; it must be the last call in the chain`), and so is storing an adapter's result (`s := xs.take(2)`).
@@ -982,7 +1048,7 @@ names := for u := range units.take(5).map(), if u.hp > 0.0
   u.name
 ```
-Performance guarantee: a whole chain is ONE loop with no closure allocation, no `call_indirect` and no intermediate `List`. The method chain below compiles to the same single loop as the hand-written one:
+Performance guarantee: a whole chain is ONE loop with no closure allocation, no `call_indirect` and no intermediate `Slice`. The method chain below compiles to the same single loop as the hand-written one:
 ```plum
 total := for acc, u := range units.skip(1).take(10).fold(0.0), if u.team == me.team
@@ -1026,7 +1092,7 @@ See [`plum-examples/seq.plum`](plum-examples/seq.plum) (one test per adapter and
 ## Optionals
-An optional is `T?`: a `T`, or `null`. It is its own type, not an error: it carries no error name, and `catch` and `try` do not apply to it. A plain `T` in a `T?` slot is the present value, and `null` is the absent value wherever a `T?` is expected (a call or constructor argument, a `return`, a tail, a list element, a parameter default such as `n: Int? = null`). An inline `if`/`match` whose branches are a `T` and `null` is a `T?`: `if inBox(p) then n.id() else null` is an `Int?`. `null` with nothing to say what it is an optional of is an error (`x := null`: `cannot infer the type of null`). For a reference type (a class, enum, `Str`, `List`, ...) a `T?` is stored as a nullable reference, so a present value costs no allocation; for `Int`, `Float`, `Bool` and structs it is the value plus a present flag, `(T..., i32)` (the `i32` is 0 when present, and the code of `null` when absent). A doubled `T??` is not allowed.
+An optional is `T?`: a `T`, or `null`. It is its own type, not an error: it carries no error name, and `catch` and `try` do not apply to it. A plain `T` in a `T?` slot is the present value, and `null` is the absent value wherever a `T?` is expected (a call or constructor argument, a `return`, a tail, a list element, a parameter default such as `n: Int? = null`). An inline `if`/`match` whose branches are a `T` and `null` is a `T?`: `if inBox(p) then n.id() else null` is an `Int?`. `null` with nothing to say what it is an optional of is an error (`x := null`: `cannot infer the type of null`). For a reference type (a class, enum, `Str`, `Slice`, ...) a `T?` is stored as a nullable reference, so a present value costs no allocation; for `Int`, `Float`, `Bool` and structs it is the value plus a present flag, `(T..., i32)` (the `i32` is 0 when present, and the code of `null` when absent). A doubled `T??` is not allowed.
 ```plum
 record Person(name: Str, age: Int)
@@ -1053,7 +1119,7 @@ fun port(cfg: Config) -> error{Unconfigured}!Int =
   p := cfg.port ?: return error.Unconfigured     # absence becomes an error
   p
-fun total(xs: List[Int?]) -> Int =
+fun total(xs: Slice[Int?]) -> Int =
   sum := 0
   for x := range xs
     if n := x
@@ -1120,7 +1186,7 @@ primitive Int =
   fun parse(s: Str) -> error{BadNumStr}!Int
 ```
-The std signatures: `List.get` fails with `OutOfBounds`, `first`/`last`/`pop`/`sample` with `ListWasEmpty`, `findValue` with `NotFound`, `Map.get` with `KeyNotFound`, `Int.parse`/`Float.parse` with `BadNumStr`, `Bool.parse` with `BadBoolStr`, `Json.fromStr` with `InvalidJson` (`Json.parse` returns where and why as an ordinary value), the `Os` file functions with `NoSuchPath`/`IoFailed` (the set `IoError` where a function can hit both), `Http.request` with `HttpFailed`/`BadResponse` (the set `HttpError`), `Uuid.fromStr` with `InvalidUuid`. Where absence is not an error the result is an optional instead: `List.head`, the `find()` terminal and `Map.getOrNull` return `T?`.
+The std signatures: `Slice.get` fails with `OutOfBounds`, `first`/`last`/`pop`/`sample` with `ListWasEmpty`, `findValue` with `NotFound`, `Map.get` with `KeyNotFound`, `Int.parse`/`Float.parse` with `BadNumStr`, `Bool.parse` with `BadBoolStr`, `Json.fromStr` with `InvalidJson` (`Json.parse` returns where and why as an ordinary value), the `Os` file functions with `NoSuchPath`/`IoFailed` (the set `IoError` where a function can hit both), `Http.request` with `HttpFailed`/`BadResponse` (the set `HttpError`), `Uuid.fromStr` with `InvalidUuid`. Where absence is not an error the result is an optional instead: `Slice.head`, the `find()` terminal and `Map.getOrNull` return `T?`.
 ### Propagating: `try expr`
@@ -1129,7 +1195,7 @@ The std signatures: `List.get` fails with `OutOfBounds`, `first`/`last`/`pop`/`s
 ```plum
 fun numAt(s: Str, i: Int) -> error{BadNumStr, OutOfBounds}!Int =
   n := try Int.parse(s)                # error{BadNumStr}
-  x := try List(10, 20, 30).get(i)    # error{OutOfBounds}
+  x := try Slice(10, 20, 30).get(i)    # error{OutOfBounds}
   n + x
 ```
@@ -1184,11 +1250,11 @@ enum Failure =
   | BadRequest
 ```
-An error union can have an optional as its success value: `!T?` (`error{Bad}!Int?`). `try x` gives the `T?`, and `?:` then handles the null: `v := try parse(s)` followed by `v ?: 0`. An error union can also be the success type of another (`List[!Int].get(i)` is a `!!Int`): unwrap it one level at a time with `!`, `try` or `catch`. See [`plum-examples/error_propagation.plum`](plum-examples/error_propagation.plum).
+An error union can have an optional as its success value: `!T?` (`error{Bad}!Int?`). `try x` gives the `T?`, and `?:` then handles the null: `v := try parse(s)` followed by `v ?: 0`. An error union can also be the success type of another (`Slice[!Int].get(i)` is a `!!Int`): unwrap it one level at a time with `!`, `try` or `catch`. See [`plum-examples/error_propagation.plum`](plum-examples/error_propagation.plum).
 ### Runtime representation
-Each error name gets a global `i32` code, interned in sorted order from 1 (0 means success). An optional `T?` uses the same layout (see [Optionals](#optionals)). A `!T` result is a multi-value return `(T..., i32)`, so neither success nor failure allocates; stored in a heap slot (a field, a `List` element, a generic container) it is boxed into a `{value, code}` struct.
+Each error name gets a global `i32` code, interned in sorted order from 1 (0 means success). An optional `T?` uses the same layout (see [Optionals](#optionals)). A `!T` result is a multi-value return `(T..., i32)`, so neither success nor failure allocates; stored in a heap slot (a field, a `Slice` element, a generic container) it is boxed into a `{value, code}` struct.
 ## Testing
@@ -1314,9 +1380,9 @@ record World(stage: Stage, wasDown: Bool)
 export fun init() -> World =
   spr := PureScene.sprite(2, 0, 100.0, 100.0, 48.0, 48.0)
-  spr.actions = List(Actions.forever(Actions.rotateBy(1.0, 1.0)))
+  spr.actions = Slice(Actions.forever(Actions.rotateBy(1.0, 1.0)))
   sp: Actor := spr
-  kids := List[Actor]()
+  kids := Slice[Actor]()
   kids.push(sp)
   root: Actor := PureScene.group(1, 0.0, 0.0, 800.0, 600.0, kids)
   World(stage: SceneInput.stage(root), wasDown: false)
@@ -1374,8 +1440,8 @@ export fun draw(w: World) =
 - **`Str`** (`import std/Str`) — an immutable view of a packed byte array, with a codepoint-aware layer for Unicode correctness (`runeLength`, `runeAt`, `codePointAt`, `Str.codePointToStr(cp)`). Substrings (`sub`, `slice`, `trim*`, `split` parts) share their source's bytes instead of copying; `s.clone()` detaches one
 - **`Byte`** (`import std/Byte`) — a scalar unsigned 8-bit value; `Array[Byte]` stores one byte per element
 - **`Buffer`** (`import std/Buffer`) — a growable, mutable byte sequence for building up a `Str`, amortized O(n) writes
-- **`Array[T]`** (`import std/Array`) — the compiler-intrinsic fixed-length array that `List`, `Map` and `Str` are written on, with `Array.copy` and `Array.equal` for scalar ranges; `Grid[T]` is a flat 2D array
-- **`List[T]`** (`import std/List`) — a growable list built on `Array`, with `get`/`add`/`set`/`removeAt`/`remove`/`sort`/`join`/`chunk` (iteration and transformation via `for`). `xs.slice(i, j)` returns a view: a `List` over the same storage, with no copy. `set` on a view changes the original and a `push` on a view moves it to its own storage first; reordering the original in place (`removeAt`, `reverse`) is visible through its views, so use `sublist(i, j)` for a copy
+- **`Array[T]`** (`import std/Array`) — the compiler-intrinsic fixed-length array that `Slice`, `Map` and `Str` are written on, with `Array.copy` and `Array.equal` for scalar ranges; `Grid[T]` is a flat 2D array
+- **`Slice[T]`** (`import std/Slice`) — a growable list built on `Array`, with `get`/`add`/`set`/`removeAt`/`remove`/`sort`/`join`/`chunk` (iteration and transformation via `for`). `xs.slice(i, j)` returns a view: a `Slice` over the same storage, with no copy. `set` on a view changes the original and a `push` on a view moves it to its own storage first; reordering the original in place (`removeAt`, `reverse`) is visible through its views, so use `sublist(i, j)` for a copy
 - **`Map[K, V]`** (`import std/Map`) — `Map("a" => 1, "b" => 2)` builds a `Map[Str, Int]`; `Map[K, V]()` is empty. `k => v` is sugar for `Pair(k, v)` in any call's argument list, and a key can be any expression (`Map(n + 1 => x)`). A later duplicate key wins, as with `set`. See [`plum-examples/maps.plum`](plum-examples/maps.plum)
 - **`Set[T]`**, **`Deque[T]`**, **`Heap[T]`** — a set over `Map`'s bucketed hash table, a ring-buffer double-ended queue and a key-ordered min-heap
 - **`Seq[T]`** (`import std/Seq`) — the adapters and terminals of the `for` chains
@@ -1387,7 +1453,7 @@ See [`plum-examples/`](plum-examples) for a runnable file per feature above, and
 ### JSON
-`import std/Json` adds `Json.encode(x)` and `Json.decode(s)`. A type encodes when it has `toJson(self) -> Json` and decodes when it has a static `fromJson(j: Json) -> JsonError!T`. `Int`, `Float`, `Bool`, `Str`, `List[T]` and `Map[K, V]` get both methods from `std/Json`, so they exist only in programs that import it. `Int.fromJson` rejects fractions and magnitudes of 2^53 or more. `decode` takes `T` from the annotation, and `JsonError` is `InvalidJson | WrongJsonType | MissingField`.
+`import std/Json` adds `Json.encode(x)` and `Json.decode(s)`. A type encodes when it has `toJson(self) -> Json` and decodes when it has a static `fromJson(j: Json) -> JsonError!T`. `Int`, `Float`, `Bool`, `Str`, `Slice[T]` and `Map[K, V]` get both methods from `std/Json`, so they exist only in programs that import it. `Int.fromJson` rejects fractions and magnitudes of 2^53 or more. `decode` takes `T` from the annotation, and `JsonError` is `InvalidJson | WrongJsonType | MissingField`.
 ```plum
 record Point(x: Int, y: Int) =
@@ -1411,7 +1477,7 @@ Also available: `Json.decodeWith(s, fn)`, `j.field(name)`, `j.optField(name)`, `
 - There are no explicit call-site type arguments: `Json.decode[House](s)` does not parse, so annotate the result instead.
 - Optionals `T?` have no built-in `toJson`/`fromJson` yet; write them by hand.
-- `List[Int].fromJson(j)` does not parse; use `j.into()` or `Json.decode`.
+- `Slice[Int].fromJson(j)` does not parse; use `j.into()` or `Json.decode`.
 - Inside a generic static, prefer `try`/`!` over `catch return error.X` (a known codegen gap).
 - There is no derive: records write `toJson`/`fromJson` by hand.
@@ -1421,9 +1487,9 @@ See [`plum-examples/json.plum`](plum-examples/json.plum).
 These are compiler optimizations, not language changes; none of them changes what a program means or how it is written.
-- **No allocation for local lists and views.** A `List`, a `List.slice` view or a `Str` substring that never leaves its function (isn't stored, passed on or returned) could keep its fields in locals instead of allocating its small record (escape analysis).
+- **No allocation for local lists and views.** A `Slice`, a `Slice.slice` view or a `Str` substring that never leaves its function (isn't stored, passed on or returned) could keep its fields in locals instead of allocating its small record (escape analysis).
 - **Loops read a list once.** `for x := range xs` could read `xs`'s storage, start and size once before the loop instead of on every step, and `xs.get(i)` loops could do the same when the body can't change `xs`.
-- **Inlined `get`, `set` and `push`.** These small `List` and `Array` methods are function calls today. Inlining them removes the call and lets the wasm engine keep values in registers.
+- **Inlined `get`, `set` and `push`.** These small `Slice` and `Array` methods are function calls today. Inlining them removes the call and lets the wasm engine keep values in registers.
 - **No placeholder `self` for statics.** A static such as `Vec2.zero()` still receives an unused `self` slot (one per field for a struct), which could be dropped from its signature.
 - **Fewer boxed structs.** A struct stored in a record field, passed as a variadic argument or carried in an error union is boxed (one allocation); it could be stored inline instead.
 - **Host string reads.** When the host prints or writes a `Str`, it copies the whole backing array and then takes the `[start, start + len)` part; it could copy only that range.

docs/plans/2026-11-03-unboxed-variants.benchmark.md ADDED Viewed

@@ -0,0 +1,23 @@
+# Unboxed variants benchmark
+Date 2026-11-03. Same probe shape as `2026-11-03-gc-report.md`: `fromTo` (tail modulo cons) then `length`, and an
+accumulator `build` then `fold` sum, over std `List[Int]` (Nil/Cons, one `struct.new` per cell). Dev build of
+plum-cli (wasmtime crates at opt-level 3), wall time of the whole `plum test <file>` run (about 100 ms of it is
+compile), 3 runs each, median. Probes: /private/tmp/claude-501/t9/.
+| Probe | Before (boxed Link, gc-report) | After (unboxed List), runs | After median |
+|---|---|---|---|
+| fromTo+length 100k | 1830 ms (cold) | 149, 150, 147 | 149 ms |
+| fromTo+length 1M | 1238 ms | 192, 188, 194 | 192 ms |
+| build+sum 100k | - | 145, 149, 149 | 149 ms |
+| build+sum 1M | ~280 ms | 202, 201, 194 | 201 ms |
+| `plum test cons_list.plum tail_calls.plum` | - | 2083, 2107, 2098 | 2098 ms |
+## Verdict
+Unboxed variants make the 1M-cell build+length about 6.4x faster (1,238 ms to 192 ms, of which about 100 ms is
+compile), and the superlinear growth is gone: 100k to 1M now costs 1.3x for 10x the cells, where it was far worse
+before. build+sum improves less (280 to 201 ms) because it was already cheap. One allocation per cell (instead of
+a variant box plus a payload) halves live objects, so the semi-space copying collector has far less to copy. The
+two test files (about 2.1 s) are dominated by their many other tests and are given for reference only; no
+"before" figure was recorded for them.

docs/plans/2026-11-03-unboxed-variants.md ADDED Viewed

@@ -0,0 +1,174 @@
+# Unboxed variants, enum constructors, List -> Slice, cons List
+**Review plan:** docs/plans/2026-11-03-unboxed-variants.review.md
+**Goal:** rename the growable `List` to `Slice` everywhere; `EnumName(args)` calls the enum's static `init`; inline-variant and union-enum members become wasm-gc subtypes of the enum (one allocation per value); a new std cons `List[T]`; recursive code moves to it. `Array` unchanged.
+**Architecture:** rename first (std file, compiler special cases, all users); enum init routing in checker+codegen; unboxed layout reuses the subtyped-trait path in plum-wasm-codegen; then plum-std/List.plum is the cons list.
+**Tech stack:** Rust (plum-core, plum-checker, plum-wasm-codegen, plum-lsp), Plum std/examples, plum-game fixtures.
+**Spec:** docs/plans/2026-11-03-unboxed-variants.review.md
+**Detail:** contracts
+**Target-min:** 60
+## Global constraints
+- Work only in /Users/pyrossh/Code/plum-pure-scene-values (branch pure-scene-values, base 614ddf5). Never touch /Users/pyrossh/Code/plum or ../kam_plum.
+- Plum: `touch plum-cli/src/main.rs && cargo build --quiet -p plum-cli && ./target/debug/plum test <files>`; sweep `./target/debug/plum test plum-std plum-examples` (611 green, ~21 s). Rust: `cargo test --manifest-path <crate>/Cargo.toml [--test name]`. Known failing: plum-checker `generic_funstar_wired` (untracked repro) — ignore.
+- Rename rule: the type `List` (growable record over Array) becomes `Slice`; file plum-std/List.plum becomes plum-std/Slice.plum; imports `std/List` -> `std/Slice`; `List(...)`, `List[T]`, `List.x` -> `Slice...`. Method names, behaviour and test names stay the same except where a test name literally says "list" about the type (keep names unless they would mislead). Do not rename the identifier `Link` or unrelated words (`listen`, `ListItem` in LSP protocol types).
+- The new cons List must not exist until the rename is complete (no stray old use may type-check against it).
+- Never run `plum format` on real files. Grammar is unaffected.
+```mermaid
+flowchart LR
+  R1["rename: compiler + std"] --> R2["rename: examples + fixtures"]
+  R1 --> R3["rename: Rust tests + README"]
+  EI["enum init routing"] --> L5["unboxed: construct"] --> L6["unboxed: match/access"]
+  R2 --> CL["std cons List"]
+  R3 --> CL
+  EI --> CL
+  CL --> MV["move recursive code"]
+  L6 --> PD["perf + docs"]
+  MV --> PD
+```
+File structure: each task's Owns. Spec coverage: What you will get (T1-T9), What will be built (T1-T9), How it fits together (diagram), Decisions you can change (defaults in constraints), Risks (R1 T1-T3, R2 T7, R3 T5/T6), Out of scope (not built), How we will know it works (T1-T9), Rough time and cost (schedule).
+## Task graph
+```mermaid
+flowchart LR
+  T1[rename compiler std]
+  T2[rename examples fixtures]
+  T3[rename tests readme]
+  T4[enum init routing]
+  T5[unboxed construct]
+  T6[unboxed use]
+  T7[std cons List]
+  T8[move recursive code]
+  T9[perf and docs]
+  %% taskgraph
+  T1 --> T2
+  T1 --> T3
+  T4 --> T5
+  T5 --> T6
+  T2 --> T7
+  T3 --> T7
+  T4 --> T7
+  T7 --> T8
+  T6 --> T9
+  T8 --> T9
+```
+## Rename
+### T1 rename List to Slice: compiler and std · Complexity 4 · Est. context 50k
+**Owns:** plum-std/List.plum, plum-std/Slice.plum, plum-std/*.plum, plum-std/game/*.plum, plum-core/src/forms.rs, plum-core/src/loader.rs, plum-checker/src/ownership.rs, plum-lsp/src/main.rs, plum-lsp/src/completion.rs
+**Components:** 2
+**LOC owned:** 150
+**Tests:** fast
+**Kind:** design
+**Model:** sonnet
+**Consumes:** none
+**Produces:** none
+**Review Focus:** encoding R1: `git mv plum-std/List.plum plum-std/Slice.plum`, `record Slice[T]`; every std file and std/game file updated; forms.rs builds `Slice` where it built `List` (for-chains, collect); ownership.rs R2 rule on `Slice`; LSP completions/hover names.
+**Test code:** `./target/debug/plum test plum-std` all green (same counts as before the rename); `cargo build --workspace`; plum-core/plum-checker test binaries green except tests whose embedded sources say `List` (T3 fixes those — list them).
+### T2 rename List to Slice: examples and fixtures · Complexity 2 · Est. context 35k
+**Owns:** plum-examples/*.plum, plum-game/web-test/fixtures/*.plum, plum-game/examples/*.plum
+**Components:** 1
+**LOC owned:** 120
+**Tests:** fast
+**Kind:** mechanical
+**Model:** haiku
+**Consumes:** none
+**Produces:** none
+**Review Focus:** encoding: only the type rename; `Link` and game logic untouched.
+**Test code:** `./target/debug/plum test plum-examples` green with the same test count (611 total with std); every fixture under plum-game/web-test/fixtures compiles (`./target/debug/plum compile <f>`).
+### T3 rename List to Slice: Rust tests and README · Complexity 2 · Est. context 35k
+**Owns:** plum-core/tests/*.rs, plum-checker/tests/*.rs, plum-wasm-codegen/tests/*.rs, plum-game/tests/*.rs, README.md
+**Components:** 1
+**LOC owned:** 120
+**Tests:** fast
+**Kind:** mechanical
+**Model:** haiku
+**Consumes:** none
+**Produces:** none
+**Review Focus:** encoding: embedded Plum sources and expected messages renamed; README prose says Slice for the growable type and keeps Array text.
+**Test code:** every test binary in plum-core, plum-checker, plum-wasm-codegen, plum-game green (except generic_funstar_wired); README code blocks mentioning `List` updated.
+## Enum constructors and layout
+### T4 enum init routing · Complexity 4 · Est. context 45k
+**Owns:** plum-checker/src/lib.rs, plum-wasm-codegen/src/lib.rs, plum-wasm-codegen/tests/enum_init_e2e_test.rs
+**Components:** 1
+**LOC owned:** 120
+**Tests:** fast
+**Model:** sonnet
+**Consumes:** none
+**Produces:** EnumName(args) resolves to the enum's static `init`
+e.g. `Link(1, 2, 3, 4).sum()` -> `10` (enum Link with `fun init(values: ...T) -> Link[T]`)
+e.g. `Shape(1)` on an enum without init -> error `Shape has no init; construct a variant or declare `fun init``
+**Review Focus:** state: variant names win over init; generic T from args or expected type (`xs: Link[Int] = Link()` is Nil); fixed-param init works; today's codegen error `unknown function 'Link'` gone.
+**Test code:** enum_init_e2e_test.rs: `variadic_init_builds_list`, `empty_init_with_annotation`, `fixed_param_init`, `no_init_error_message`, `variant_name_wins`, `generic_inferred_from_args`. Use an enum named `Link` in tests (the std List rename is in flight).
+### T5 unboxed variants: layout and construction · Complexity 6 · Est. context 65k
+**Owns:** plum-wasm-codegen/src/lib.rs, plum-wasm-codegen/tests/unboxed_variants_e2e_test.rs
+**Components:** 1
+**LOC owned:** 180
+**Tests:** fast
+**Model:** sonnet
+**Consumes:** none
+**Produces:** none
+**Review Focus:** state R3: inline-variant hidden records and union-enum member records become wasm-gc subtypes of the enum supertype (reuse the subtyped-trait path, `subtypedTraits` / hidden member variants ~l.1043); no hidden wrapper struct is emitted; nullary tags unchanged; generics per instantiation.
+**Test code:** unboxed_variants_e2e_test.rs: `cons_one_struct_new` (wasmparser: constructing `Cons(head: 1, tail: Nil)` emits one struct.new), `union_member_one_struct_new` (`enum Shape = Circle | Rect`), `generic_link_instantiations_separate`, `own_record_member_ok`. Existing union/inline-variant tests may fail on match/access until T6 — list them; construction-only tests must pass.
+### T6 unboxed variants: match, access, equality, toStr, Json · Complexity 6 · Est. context 65k
+**Owns:** plum-wasm-codegen/src/lib.rs, plum-wasm-codegen/tests/unboxed_variants_e2e_test.rs, plum-core/tests/trmc_test.rs
+**Components:** 1
+**LOC owned:** 180
+**Tests:** fast
+**Model:** sonnet
+**Consumes:** none
+**Produces:** none
+**Review Focus:** state: match via br_on_cast / ref.test on the member struct; field read one struct.get; equality, toStr, Json encode/decode, trait dispatch on union members all on the new layout.
+**Test code:** add `match_member_fields`, `nested_enum_match`, `equality_and_toStr`, `json_round_trip_union` to unboxed_variants_e2e_test.rs; trmc_test struct.new-per-cell assertion 2 -> 1; whole plum-wasm-codegen suite, plum-core trmc_test and the full Plum sweep green.
+## Cons List
+### T7 std cons List · Complexity 4 · Est. context 45k
+**Owns:** plum-std/List.plum, plum-examples/cons_list.plum
+**Components:** 1
+**LOC owned:** 170
+**Tests:** fast
+**Model:** sonnet
+**Consumes:** EnumName(args) resolves to the enum's static `init`
+**Produces:** std/List: `enum List[T] = Nil | Cons(head: T, tail: List[T])` with init, map, filter, fold, reverse, append, length, at, isEmpty, toStr, equals, a `fun*` iterator, toSlice, toArray; `Slice.toList()` added in plum-std/Slice.plum (allowed edit)
+e.g. `List(1, 2, 3, 4).fold(0, |a, x| a + x)` -> `10`
+e.g. `List(1, 2, 3).map(|x| x * 2).toSlice()` -> `Slice(2, 4, 6)`
+**Review Focus:** deep R2: recursive definitions that tail-call or TRMC (constant stack at 1M); `for x := range xs` works; no old-List use type-checks against it (grep plum-std plum-examples for `List` outside this file and cons_list.plum: expect none).
+**Test code:** cons_list.plum: `init_sum`, `map_filter_fold`, `reverse_append`, `for_range`, `to_slice_round_trip`, `to_array`, `map_million` (1,000,000), `fold_million`, `equals_and_toStr`.
+### T8 move recursive code to std List · Complexity 4 · Est. context 50k
+**Owns:** plum-std/game/Picture.plum, plum-examples/game_state_view.plum, plum-examples/functional.plum, plum-examples/tail_calls.plum, plum-game/web-test/fixtures/stress_state_view.plum, plum-game/web-test/fixtures/stress_state_view_deep.plum
+**Components:** 2
+**LOC owned:** 160
+**Tests:** fast
+**Model:** sonnet
+**Consumes:** none
+**Produces:** none
+**Review Focus:** state: local `Link`/`Nodes` types replaced by std `List` (Picture children `List[SceneNode]`); same test names and values; functional.plum keeps teaching value (its own Link section may stay as the "how it's built" example if removing it loses that — say which).
+**Test code:** all six files green with unchanged test names/values; `cargo test --manifest-path plum-game/web-test/Cargo.toml --test web_check state_view` passes.
+## Wrap-up
+### T9 perf and docs · Complexity 2 · Est. context 30k
+**Owns:** README.md, docs/plans/2026-11-03-unboxed-variants.benchmark.md
+**Components:** 1
+**LOC owned:** 80
+**Tests:** fast
+**Model:** sonnet
+**Consumes:** none
+**Produces:** none
+**Review Focus:** numeric: 1M `List` build+walk timed before (git stash-free: use the T4 checkpoint binary or note) and after; README sections: List (cons, default for recursion), Slice (growable view over Array), Array (fixed, unchanged), `Type(...)` calls init for enums.
+**Test code:** README examples compile (scratch file under /private/tmp/claude-501/); benchmark doc with the timing table.
+## Review Focus
+- compiler: deep, state, encoding. Risks: incomplete rename; layout regressions in match/Json/toStr; init vs variant resolution.
+**Probe entry:** run=./target/debug/plum test

docs/plans/2026-11-03-unboxed-variants.progress.md ADDED Viewed

@@ -0,0 +1,41 @@
+# Unboxed variants / Slice / cons List run
+- start 614ddf5
+- Ruling: skip T0 Wave 0 - no Plum/Rust stub generation - cost if wrong: none
+- unblocked: dispatched T1 T4 at 18:15:08
+- checkpoint T1 5a9780d17e rename List to Slice: compiler and std
+- T1 checkpointed 5a9780d (std + compiler special cases; plum-std 224/0)
+- unblocked: dispatched T2 T3 at 18:17:17
+- Ruling: delete stale probe fixture stress_pure_scene_inplace.plum - unchecked in-place writes now rejected by the ownership checker (Actor is own); its result is recorded in own-record.benchmark.md; stays in git history - cost if wrong: re-create from history
+- checkpoint T2 00cc295e01 rename List to Slice: examples and fixtures
+- checkpoint T4 646ad682c8 enum init routing
+- T4 checkpointed 646ad68 (enum init routing)
+- F-T4-1 queued: bare `out := Nil` in a generic fn emits invalid wasm (type mismatch ref null) - fixer after T6 (codegen file busy)
+- unblocked: dispatched T5 at 18:20:47; T3 running
+- checkpoint T3 817c58420e rename List to Slice: Rust tests and README
+- T3 checkpointed 817c584 (Rust tests + README; checker 159/1 known, codegen 186/0, host 17)
+- unblocked: dispatched T7 at 18:21:15 (T5 running)
+- checkpoint T7 34f6456e45 std cons List
+- T7 checkpointed 34f6456: std cons List (9/9 incl 1M). Concerns: Cons/Nil now global std names (local Link enums collide -> T8 migrates); for-range over List quadratic (F-T7-1 fixer); TRMC doesn't fire on methods -> map delegates to exported free fn mapCells (follow-up)
+- unblocked: dispatched T8 + F-T7-1 fixer at 18:25:26 (T5 running)
+- checkpoint T5 b881bc7f8e unboxed variants: layout and construction
+- T5 checkpointed (unboxed layout: member records subtypes of enum supertype, no wrapper; 4 tests pass; matching already works via trait-member path)
+- Ruling: Slice must not import List (remove Slice.toList, add List.fromSlice) - std Cons/Nil leaked into every Slice user, 17 codegen tests failed to load - cost if wrong: one less convenience method
+- F-T7-2 to fixer-sonnet at 18:25:47
+- unblocked: dispatched T6 at 18:26:02
+- checkpoint T8 1d2cc48c6c move recursive code to std List
+- T8 checkpointed: Picture/state_view/fixtures/tail_calls on std List; functional.plum keeps its own Chain = Empty | Link teaching section; sweep 620/0, web_check state_view ok
+- checkpoint T1 ca5805e887 rename List to Slice: compiler and std
+- F-T7-1 FIXED: for x := range xs uses fun* items when declared (std List); 1M sum 0.2s
+- checkpoint T7 dba185aa2b std cons List
+- F-T7-2 FIXED (Slice no longer imports List; List.fromSlice). Watch: codegen_tests terminal_mid_chain_error (filter().take) failing - check after T6 (possible forms items lookup)
+- checkpoint T6 a035d2a6dc unboxed variants: match, access, equality, toStr, Json
+- T6 checkpointed a035d2a: no codegen change needed for access/eq/toStr/Json; trmc 1 struct.new/cell; 8 unboxed tests. Notes: == on records/enums is reference identity; Json.decode into a union fails ('members disagree') - follow-ups
+- F-T7-1b: terminal_mid_chain_error regressed (error text) by items lookup -> back to same fixer
+- unblocked: dispatched T9 at 18:30:03
+- checkpoint T9 ee2f11856b perf and docs
+- T9 checkpointed: 1M fromTo+length 1238 -> 192 ms (6.4x); README List/Slice/Array + enum init
+- checkpoint T1 601fb9237d rename List to Slice: compiler and std
+- F-T7-1b FIXED: resolve() returns early when fatal, mid-chain error text restored
+- Final review CHANGES_REQUESTED: deep + state probe categories unverified -> F-FR-1 fixer-sonnet-high (permanent tests in plum-examples/unboxed_variants.plum)
+- tests full passed=80 failed=1 skipped=0 seconds=39.9
+- F-FR-1 FIXED: 9 deep/state probes in plum-examples/unboxed_variants.plum, no defects; full suite only known generic_funstar_wired. Final review findings addressed.

docs/plans/2026-11-03-unboxed-variants.report.json ADDED Viewed

@@ -0,0 +1,363 @@
+{
+ "projection_note": "projection: fixed forecast saved at lint 2026-11-03T18:14:44",
+ "headline": {
+  "wall_min": {
+   "projected": 29.698,
+   "actual": 16.277
+  },
+  "cost_usd_agents": {
+   "projected": 0.888557,
+   "actual": 2.2806
+  },
+  "task_min": {
+   "projected": 54.511,
+   "actual": 27.99
+  },
+  "agents": {
+   "projected": 9,
+   "actual": 24
+  }
+ },
+ "feature": null,
+ "cost_split": {
+  "agents_usd": 1.965493,
+  "rework_usd": 0.315107,
+  "coordinator_usd": 44.341197,
+  "total_usd": 46.621797
+ },
+ "concurrency": {
+  "peak": 3,
+  "projected_peak": 3
+ },
+ "critical_path": {
+  "actual": [
+   "T1",
+   "T3",
+   "T7"
+  ],
+  "projected": [
+   "T1",
+   "T2",
+   "T7",
+   "T8",
+   "T9"
+  ],
+  "projected_min": 29.698
+ },
+ "model_mix": {
+  "sonnet": {
+   "tasks": 8,
+   "cost_usd": 2.259574
+  },
+  "haiku": {
+   "tasks": 1,
+   "cost_usd": 0.021026
+  }
+ },
+ "coordinator_cost_by_model": {
+  "opus": 44.341197
+ },
+ "quality": {
+  "tests": {
+   "passed": 80,
+   "failed": 1,
+   "skipped": 0,
+   "seconds": 39.9,
+   "mode": "full",
+   "failures": [
+    "-::generic_funstar_wired: failed"
+   ],
+   "skipped_tests": []
+  },
+  "first_time_pass": 0,
+  "first_time_n": 0,
+  "rework_dispatches": 2,
+  "open_incidents": 1
+ },
+ "tasks": [
+  {
+   "task": "T1",
+   "model": "sonnet",
+   "pred_min": 7.016,
+   "actual_min": 1.73,
+   "delta": {
+    "abs": -5.286,
+    "pct": -75.3
+   },
+   "cost_usd": 0.119092,
+   "first_time_pass": null
+  },
+  {
+   "task": "T8",
+   "model": "sonnet",
+   "pred_min": 7.367,
+   "actual_min": 2.417,
+   "delta": {
+    "abs": -4.9503,
+    "pct": -67.2
+   },
+   "cost_usd": 0.201661,
+   "first_time_pass": null
+  },
+  {
+   "task": "T6",
+   "model": "sonnet",
+   "pred_min": 7.746,
+   "actual_min": 3.307,
+   "delta": {
+    "abs": -4.4393,
+    "pct": -57.3
+   },
+   "cost_usd": 0.308496,
+   "first_time_pass": null
+  },
+  {
+   "task": "T7",
+   "model": "sonnet",
+   "pred_min": 7.396,
+   "actual_min": 3.617,
+   "delta": {
+    "abs": -3.7793,
+    "pct": -51.1
+   },
+   "cost_usd": 0.599778,
+   "first_time_pass": null
+  },
+  {
+   "task": "T5",
+   "model": "sonnet",
+   "pred_min": 7.746,
+   "actual_min": 4.338,
+   "delta": {
+    "abs": -3.4077,
+    "pct": -44.0
+   },
+   "cost_usd": 0.48981,
+   "first_time_pass": null
+  },
+  {
+   "task": "T9",
+   "model": "sonnet",
+   "pred_min": 4.24,
+   "actual_min": 1.07,
+   "delta": {
+    "abs": -3.17,
+    "pct": -74.8
+   },
+   "cost_usd": 0.133305,
+   "first_time_pass": null
+  },
+  {
+   "task": "T2",
+   "model": "sonnet",
+   "pred_min": 3.679,
+   "actual_min": 2.51,
+   "delta": {
+    "abs": -1.169,
+    "pct": -31.8
+   },
+   "cost_usd": 0.133804,
+   "first_time_pass": null
+  },
+  {
+   "task": "T4",
+   "model": "sonnet",
+   "pred_min": 5.642,
+   "actual_min": 5.353,
+   "delta": {
+    "abs": -0.2887,
+    "pct": -5.1
+   },
+   "cost_usd": 0.273628,
+   "first_time_pass": null
+  },
+  {
+   "task": "T3",
+   "model": "haiku",
+   "pred_min": 3.679,
+   "actual_min": 3.648,
+   "delta": {
+    "abs": -0.0307,
+    "pct": -0.8
+   },
+   "cost_usd": 0.021026,
+   "first_time_pass": null
+  }
+ ],
+ "cost_table": {
+  "source": "est",
+  "usd": 2.8374,
+  "tokens": 8182748,
+  "wall_min": 328846987.1948,
+  "rows": [
+   {
+    "agent": "a032d5337feb97389",
+    "model": "sonnet",
+    "wall_min": 2.4293,
+    "tokens": 422013,
+    "usd": 0.2017
+   },
+   {
+    "agent": "a1f5fcda3239f9191",
+    "model": "sonnet",
+    "wall_min": 1.735,
+    "tokens": 216036,
+    "usd": 0.1191
+   },
+   {
+    "agent": "a1fb8294a41bfce90",
+    "model": "sonnet",
+    "wall_min": 3.1865,
+    "tokens": 153822,
+    "usd": 0.0828
+   },
+   {
+    "agent": "a2d17c86204e4ed8e",
+    "model": "sonnet",
+    "wall_min": 29895181.6431,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a2f7f372bcc1913c7",
+    "model": "sonnet",
+    "wall_min": 29895165.2396,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a37b5a6af63f1a35f",
+    "model": "sonnet",
+    "wall_min": 4.1535,
+    "tokens": 1512901,
+    "usd": 0.4462
+   },
+   {
+    "agent": "a38cfc8fbcccfabf6",
+    "model": "sonnet",
+    "wall_min": 29895178.0764,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a622bd7aabd02b433",
+    "model": "opus",
+    "wall_min": 0.1906,
+    "tokens": 31675,
+    "usd": 0.1106
+   },
+   {
+    "agent": "a71ba03ecb85f82fb",
+    "model": "sonnet",
+    "wall_min": 2.5291,
+    "tokens": 385313,
+    "usd": 0.1338
+   },
+   {
+    "agent": "a78e2c30b9e5bd17e",
+    "model": "sonnet",
+    "wall_min": 5.9922,
+    "tokens": 754025,
+    "usd": 0.2323
+   },
+   {
+    "agent": "ab29ed3c92962597d",
+    "model": "sonnet",
+    "wall_min": 4.3458,
+    "tokens": 1336407,
+    "usd": 0.4898
+   },
+   {
+    "agent": "aba6257bd097fbcb1",
+    "model": "sonnet",
+    "wall_min": 29895167.3565,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "abc8fd2829ba26b9b",
+    "model": "sonnet",
+    "wall_min": 29895179.1512,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "abde52fdf4975b0da",
+    "model": "sonnet",
+    "wall_min": 29895180.1306,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "ac304e1fc35702cc2",
+    "model": "sonnet",
+    "wall_min": 5.3626,
+    "tokens": 690457,
+    "usd": 0.2736
+   },
+   {
+    "agent": "ac3b989eb4e21cc20",
+    "model": "sonnet",
+    "wall_min": 1.0814,
+    "tokens": 224911,
+    "usd": 0.1333
+   },
+   {
+    "agent": "ac3e029b64cf4ecaa",
+    "model": "haiku",
+    "wall_min": 3.6506,
+    "tokens": 807479,
+    "usd": 0.021
+   },
+   {
+    "agent": "ac46f3266ab816bb3",
+    "model": "sonnet",
+    "wall_min": 29895178.9264,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "ac5d6b29fb74e5a15",
+    "model": "sonnet",
+    "wall_min": 3.632,
+    "tokens": 836690,
+    "usd": 0.2847
+   },
+   {
+    "agent": "ad4ad08885dbf63fc",
+    "model": "sonnet",
+    "wall_min": 29895166.2977,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "ade129f06dbb62201",
+    "model": "sonnet",
+    "wall_min": 29895182.1857,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "adf8dc300c27c5d5f",
+    "model": "sonnet",
+    "wall_min": 29895185.31,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "af12c9f024ff3664d",
+    "model": "sonnet",
+    "wall_min": 29895181.2657,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "afdafaeb17521b00e",
+    "model": "sonnet",
+    "wall_min": 3.3233,
+    "tokens": 811019,
+    "usd": 0.3085
+   }
+  ]
+ }
+}

docs/plans/2026-11-03-unboxed-variants.report.md ADDED Viewed

@@ -0,0 +1,53 @@
+# superlite build report
+projection: fixed forecast saved at lint 2026-11-03T18:14:44
+                         Projected    Actual  Delta
+wall-clock (min)              29.7      16.3  -13.4 (-45%)
+agent cost (USD, +rework)      0.89      2.28  +1.39 (+157%)
+task-minutes                  54.5      28.0  -26.5 (-49%)
+agents                           9        24  +15 (+167%)
+cost split: agents $1.97, rework $0.32, coordinator $44.34, total $46.62
+concurrency: peak 3 at once (projected 3); critical path actual T1 T3 T7; projected T1 > T2 > T7 > T8 > T9 (29.7 min)
+model mix: haiku 1 tasks $0.02, sonnet 8 tasks $2.26, coordinator opus $44.34
+quality: tests 80 passed, 1 failed; first-time pass n/a; rework dispatches 2; open incidents 1
+task  model      pred  actual  delta             cost
+T1    sonnet      7.0     1.7  -5.3 (-75%)     $0.119
+T8    sonnet      7.4     2.4  -5.0 (-67%)     $0.202
+T6    sonnet      7.7     3.3  -4.4 (-57%)     $0.308
+T7    sonnet      7.4     3.6  -3.8 (-51%)     $0.600
+T5    sonnet      7.7     4.3  -3.4 (-44%)     $0.490
+(+4 smaller misses; `superlite-cli report --json` lists all)
+agent cost table:
+| agent | model | wall_min | tokens | usd |
+| --- | --- | --- | --- | --- |
+| a032d5337feb97389 | sonnet | 2.4293 | 422013 | 0.2017 |
+| a1f5fcda3239f9191 | sonnet | 1.735 | 216036 | 0.1191 |
+| a1fb8294a41bfce90 | sonnet | 3.1865 | 153822 | 0.0828 |
+| a2d17c86204e4ed8e | sonnet | 29895181.6431 | 0 | 0.0 |
+| a2f7f372bcc1913c7 | sonnet | 29895165.2396 | 0 | 0.0 |
+| a37b5a6af63f1a35f | sonnet | 4.1535 | 1512901 | 0.4462 |
+| a38cfc8fbcccfabf6 | sonnet | 29895178.0764 | 0 | 0.0 |
+| a622bd7aabd02b433 | opus | 0.1906 | 31675 | 0.1106 |
+| a71ba03ecb85f82fb | sonnet | 2.5291 | 385313 | 0.1338 |
+| a78e2c30b9e5bd17e | sonnet | 5.9922 | 754025 | 0.2323 |
+| ab29ed3c92962597d | sonnet | 4.3458 | 1336407 | 0.4898 |
+| aba6257bd097fbcb1 | sonnet | 29895167.3565 | 0 | 0.0 |
+| abc8fd2829ba26b9b | sonnet | 29895179.1512 | 0 | 0.0 |
+| abde52fdf4975b0da | sonnet | 29895180.1306 | 0 | 0.0 |
+| ac304e1fc35702cc2 | sonnet | 5.3626 | 690457 | 0.2736 |
+| ac3b989eb4e21cc20 | sonnet | 1.0814 | 224911 | 0.1333 |
+| ac3e029b64cf4ecaa | haiku | 3.6506 | 807479 | 0.021 |
+| ac46f3266ab816bb3 | sonnet | 29895178.9264 | 0 | 0.0 |
+| ac5d6b29fb74e5a15 | sonnet | 3.632 | 836690 | 0.2847 |
+| ad4ad08885dbf63fc | sonnet | 29895166.2977 | 0 | 0.0 |
+| ade129f06dbb62201 | sonnet | 29895182.1857 | 0 | 0.0 |
+| adf8dc300c27c5d5f | sonnet | 29895185.31 | 0 | 0.0 |
+| af12c9f024ff3664d | sonnet | 29895181.2657 | 0 | 0.0 |
+| afdafaeb17521b00e | sonnet | 3.3233 | 811019 | 0.3085 |
+| totals |  | 328846987.1948 | 8182748 | 2.8374 |
+cost source: est
+takeaway: ran 45% faster than projected; cost 157% over; biggest miss T1

docs/plans/2026-11-03-unboxed-variants.review.md ADDED Viewed

@@ -0,0 +1,69 @@
+# Unboxed variants, enum constructors, and List / Slice: review plan
+**Builds on:** branch `pure-scene-values` at 614ddf5: tail calls round 2, single-pass TRMC, wasmtime at opt-level 3 in dev, 611 Plum tests. Related: docs/plans/2026-11-02-go-slices.review.md, an older Go-slices idea that this plan supersedes.
+## Summary
+Three parts. `Array` is unchanged: a fixed-length, contiguous wasm-gc array, like Go, C and Rust arrays.
+1. **Unboxed variants (performance).** An inline variant (`Cons(head: T, tail: ..)`) and a union-enum member (`enum Shape = Circle | Rect`) are currently a hidden record wrapped in a hidden variant struct: two allocations per value. Subtyped traits already avoid this, with the member record as a wasm-gc subtype of the supertype. This part applies that layout to inline-variant and union enums.
+2. **Enum constructors, Pyret style.** `List(1, 2, 3)` on an enum calls its static `fun init(values: ...T)`, the same way records already reach `init`. Today the checker accepts that call on an enum, but codegen fails with `unknown function`.
+3. **Renames (user decision).**
+   - Today's growable `List[T]` becomes **`Slice[T]`**: the same record over an `Array`, with capacity growth and views. It is kept, and every use is renamed.
+   - The cons list (`Link` in the examples) becomes the new std **`List[T]`**: `enum List[T] = Nil | Cons(head: T, tail: List[T])` in `plum-std/List.plum`. It's the default list for recursive, pattern-matched code.
+## What you will get
+- **One allocation per variant value.** That covers every `Cons`, every union member, and every TRMC cell (trmc_test drops from 2 struct.new per cell to 1). Matching is one `br_on_cast`, and a field read is one `struct.get`.
+- **`Type(args)` reaches `init` for enums.** Variadic or fixed `init`, generic `T` inferred from the arguments or the expected type. An enum without `init` gives the error ``X has no init; construct a variant or declare `fun init` ``. A variant name always wins.
+- **std `List[T]` as a cons list:**
+  - `List(1, 2, 3)`, `Nil`, `Cons(head:, tail:)`;
+  - recursive `map`, `filter`, `fold`, `reverse`, `append`, `length`, `at`, `isEmpty`, `toStr`, `equals`;
+  - a `for x := range xs` iterator, so for-chains work;
+  - `toSlice()` and `toArray()`, with `Slice.toList()` going the other way.
+  Tail calls and TRMC keep these in constant stack.
+- **`Slice[T]`:** today's List, renamed across std, examples, fixtures, tests, the README, the LSP and editor grammars, with no behaviour change. std functions that return a growable list today (`Str.split`, `Map.keys`/`values`, `Json` arrays, `readdir`, …) return `Slice`.
+- **`Array[T]` unchanged** (user decision). Adding capacity would wrap it in a struct, costing an extra load on every get/set and changing what `length` means. `Slice` remains the growable type, like Go's `[]T` or Rust's `Vec`.
+- **Recursive code moves to the new `List`.** Picture's `Nodes`, the state/view game's `Link`, functional.plum and tail_calls.plum drop their local `Link` types.
+## What will be built
+| Part | What it does | Size |
+|---|---|---|
+| Rename List -> Slice | Mechanical rename in std (List.plum -> Slice.plum, every user), checker and codegen special cases, examples, fixtures, Rust tests, README, LSP, editor grammar | L, mechanical, split by area |
+| std cons List | plum-std/List.plum: enum + init + combinators + iterator + conversions; tests | M |
+| Enum init routing | Checker and codegen: `EnumName(args)` resolves to the enum's `init`; inference; the clear error | S |
+| Unboxed layout | Codegen: member structs as subtypes of the enum supertype; construction, then match / access / equality / toStr / Json | L, split in two |
+| Move recursive code | Picture, game_state_view, stress fixtures, functional.plum, tail_calls.plum use std List | M |
+| Tests, perf, docs | e2e per part; 1M list build and walk before and after; README sections for List / Slice / Array | S |
+## How it fits together
+```mermaid
+flowchart LR
+  RN["rename List -> Slice"] --> CL["new std List (cons)"]
+  EI["enum init routing"] --> CL
+  UV["unboxed variants"] --> CL
+  CL --> MV["recursive code uses List"]
+  AR["Array (unchanged)"] --> SL["Slice: growable view over Array"]
+```
+## Decisions you can change
+- **What std returns.** Default: everything that returns `List` today returns `Slice` (a pure rename). Alternative: a few return the new cons `List` (for example `Str.split`).
+- **`List(…)` call sites in existing code.** Default: after the rename every old `List(…)` becomes `Slice(…)`, and `List(…)` means the cons list. Alternative: also keep a deprecated `List` alias for one release. Not recommended, because the name now means the cons list.
+## Risks
+- **R1: rename breadth.** `List` is special-cased in the checker and codegen (for-loops, variadics, Json, Str, intrinsics). The rename is done in tested areas, one area per task, each green before the next.
+- **R2: the new List shares a name with the old one.** The rename must fully finish before the cons List exists, so that no stray old `List` use type-checks against the new type by accident.
+- **R3: the unboxed layout is wide.** It reuses the subtyped-trait path and is gated by the full suite.
+## Out of scope
+- The supercompiler (the next plan).
+- Bracket literals and list patterns (dropped).
+- kam_plum (outside this repo) needs the same `List` -> `Slice` rename. It's noted for you, not done here.
+## How we will know it works
+- After the rename, every suite stays green with no test changes other than names.
+- New `List`: `List(1, 2, 3, 4)` sums to 10; map, filter, fold and reverse at 1M; `for` over a List; round-trips through `toSlice()` and `toArray()`.
+- Unboxed variants: one struct.new per `Cons`; trmc at 1 per cell; 1M build and walk is about 2x faster than today.
+- Every suite stays green (611+ Plum, Rust crates, host parity, browser checks), and README examples compile.
+## Rough time and cost
+About 8 parts. The rename comes first, then the cons List (after enum init routing and the unboxed layout), then the code moves. Rough agent time is 80–110 minutes.

plum-checker/src/lib.rs CHANGED Viewed

@@ -5117,13 +5117,26 @@ fn inferExprInner(
             // type's name is sugar for `Type.init(1, 2, 3)` (see the `ClassCall`
             // zero-arg `Type()` handling); checked BEFORE the ordinary
             // positional-variant-construction case just below.
+            // An ENUM's own name (not one of its variants) routes the same way:
+            // `Link(1, 2)` is `Link.init(1, 2)`; variant names win (they are in
+            // `enum_variants` under their own key).
+            let isEnumName = !ctx.enum_variants.contains_key(&call.name)
+                && ctx.enum_variants.values().any(|i| i.enum_name == call.name);
+            let hasInit = ctx
+                .methods
+                .contains_key(&(call.name.clone(), "init".to_string()));
+            if isEnumName && !hasInit {
+                return Err(format!(
+                    "{} has no init; construct a variant or declare `fun init`",
+                    call.name
+                ));
+            }
-            if ctx
+            if (ctx
                 .enum_variants
                 .get(&call.name)
                 .is_some_and(|info| info.enum_name == call.name)
+                || isEnumName)
-                && ctx
+                && hasInit
-                    .methods
-                    .contains_key(&(call.name.clone(), "init".to_string()))
             {
                 // The receiver is a temporary (never recorded); the ARGUMENTS stay
                 // the original nodes so their types are recorded for codegen.

plum-checker/src/ownership.rs CHANGED Viewed

@@ -157,7 +157,7 @@ struct Cx<'a> {
     selfTy: Option<String>,
     /// Declared types of every local / param, own or not (for field typing).
     tys: HashMap<String, String>,
-    /// `List[T]` locals whose element type `T` is known.
+    /// `Slice[T]` locals whose element type `T` is known.
     elems: HashMap<String, String>,
     traits: HashMap<String, &'a TraitDecl>,
     /// The current path ended in return/crash/break/continue.
@@ -222,7 +222,7 @@ impl<'a> Cx<'a> {
     fn noteType(&mut self, name: &str, t: &Type) {
         self.tys.insert(name.to_string(), t.name.clone());
-        if t.name == "List" {
+        if t.name == "Slice" {
             if let Some(e) = t.generics.first() {
                 if self.own.contains(&e.name) {
                     self.elems.insert(name.to_string(), e.name.clone());

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -137,11 +137,11 @@ fn errText(r: Result<(), Vec<CheckError>>) -> String {
 // ---- structural generics (T2) ----
 const GENERIC_DEFS: &str = "\
-enum List[T] =
+enum Slice[T] =
-  | List(items: T)
+  | Slice(items: T)
-  fun map(self, cb: fn(T) -> U) -> List[U] =
+  fun map(self, cb: fn(T) -> U) -> Slice[U] =
-    List(items: cb(self.items))
+    Slice(items: cb(self.items))
 enum Box[T] =
   | Box(value: T)
@@ -194,16 +194,16 @@ fn lastFnBodyType(src: &str) -> PlumType {
 #[test]
 fn method_own_generic_instantiated_per_call() {
     assert_eq!(
-        lastFnBodyType("fun f(xs: List[Int]) -> List[Int] =\n  xs.map(|n| n * 2)\n"),
+        lastFnBodyType("fun f(xs: Slice[Int]) -> Slice[Int] =\n  xs.map(|n| n * 2)\n"),
-        tapp("List", vec![PlumType::TInt])
+        tapp("Slice", vec![PlumType::TInt])
     );
     assert_eq!(
-        lastFnBodyType("fun f(xs: List[Int]) -> List[Str] =\n  xs.map(|n| \"{n}\")\n"),
+        lastFnBodyType("fun f(xs: Slice[Int]) -> Slice[Str] =\n  xs.map(|n| \"{n}\")\n"),
-        tapp("List", vec![plum_checker::types::strType()])
+        tapp("Slice", vec![plum_checker::types::strType()])
     );
     // The two instantiations are independent: Str result where Int is declared is an error.
     let bad = checkSource(&parseClean(&format!(
-        "{}fun f(xs: List[Int]) -> List[Int] =\n  xs.map(|n| \"{{n}}\")\n",
+        "{}fun f(xs: Slice[Int]) -> Slice[Int] =\n  xs.map(|n| \"{{n}}\")\n",
         GENERIC_DEFS
     )));
     assert!(errText(bad).contains("type mismatch"));
@@ -259,14 +259,14 @@ fn nested_instantiation_chain() {
 #[test]
 fn instantiation_set_listed() {
     let src = format!(
-        "{}fun main() -> Int =\n  a := List(items: 1).map(|n| n * 2)\n  b := List(items: \"x\").map(|s| s)\n  0\n",
+        "{}fun main() -> Int =\n  a := Slice(items: 1).map(|n| n * 2)\n  b := Slice(items: \"x\").map(|s| s)\n  0\n",
         GENERIC_DEFS
     );
     let info = plum_checker::typedSource(&parseClean(&src)).unwrap_or_else(|e| panic!("{:?}", e));
     let has = |t: PlumType| {
         info.instantiations
             .iter()
-            .any(|i| i.item == "List.map" && i.type_args.first() == Some(&t))
+            .any(|i| i.item == "Slice.map" && i.type_args.first() == Some(&t))
     };
     assert!(
         has(PlumType::TInt) && has(plum_checker::types::strType()),
@@ -717,9 +717,9 @@ fn rejects_bad_generics_and_duck_typed_calls() {
         r("fun identity(value: T) -> T =\n  value\n\nfun a() -> Str =\n  identity(5)\n", &["expected Str, found Int"]),
         r("fun f(x: T) -> Int =\n  x\n\nfun main() -> Int =\n  f(\"s\")\n", &["in f[Str]"]),
         r("enum Box[T] =\n  | Box(value: T)\n\n  fun get(self) -> Int =\n    self.value\n\nfun main() -> Int =\n  Box(value: \"s\").get()\n", &["in Box.get[Str]"]),
-        r(&generic("fun f() -> List[Box[Str]] =\n  List(items: Box(value: 1))\n"), &["variant 'Box' field 'value': type mismatch"]),
+        r(&generic("fun f() -> Slice[Box[Str]] =\n  Slice(items: Box(value: 1))\n"), &["variant 'Box' field 'value': type mismatch"]),
-        r(&generic("fun f() -> List[Str] =\n  List(items: 1).map(|x| x + 1)\n"), &["method 'List.map' arg 0: type mismatch"]),
+        r(&generic("fun f() -> Slice[Str] =\n  Slice(items: 1).map(|x| x + 1)\n"), &["method 'Slice.map' arg 0: type mismatch"]),
-        r(&generic("fun f(xs: List[Int]) -> List[Int] =\n  xs.map(|n| \"{n}\")\n"), &["type mismatch"]),
+        r(&generic("fun f(xs: Slice[Int]) -> Slice[Int] =\n  xs.map(|n| \"{n}\")\n"), &["type mismatch"]),
         r("enum Parcel[T] =\n  | Delivered(T)\n  | Lost\n\nfun contentsOr(p: Parcel, default: Int) -> Int =\n  match p\n    Delivered(v) => v\n    Lost => default\n", &["generic type 'Parcel' needs type arguments, e.g. Parcel[T]"]),
         // error sets are covariant in generic arguments, not contravariant
         r(&generic("fun narrow(b: Box[error{A}!Int]) -> Int =\n  1\n\nfun bad(b: Box[error{A, B}!Int]) -> Int =\n  narrow(b)\n"), &["is not in the pinned error set error{A}"]),
@@ -744,8 +744,8 @@ fn rejects_bad_for_forms_and_fun_stars() {
         r("fun main() -> Int =\n  yield 1\n  0\n", &["yield is only allowed inside a fun*"]),
         r("fun* broken(n: Int) *Int =\n  yield n + nope\n\nfun main() -> Int =\n  0\n", &["fun* 'broken'", "nope"]),
         r(&format!("{tw}fun main() -> Int =\n  for i := range twice(4)\n    undefinedName\n  0\n"), &["undefinedName"]),
-        r("fun* leak(src: *T) *T =\n  saved := src\n  for x := range saved\n    yield x\n\nfun main() -> Int =\n  for i := range leak(List(1))\n    i\n  0\n", &["sequence parameter 'src' can only be used as a for source"]),
-        r("fun* leak(src: *T) *T =\n  for x := range src\n    yield x\n  src\n\nfun main() -> Int =\n  for i := range leak(List(1))\n    i\n  0\n", &["sequence parameter 'src' can only be used as a for source"]),
+        r("fun* leak(src: *T) *T =\n  saved := src\n  for x := range saved\n    yield x\n\nfun main() -> Int =\n  for i := range leak(Slice(1))\n    i\n  0\n", &["sequence parameter 'src' can only be used as a for source"]),
+        r("fun* leak(src: *T) *T =\n  for x := range src\n    yield x\n  src\n\nfun main() -> Int =\n  for i := range leak(Slice(1))\n    i\n  0\n", &["sequence parameter 'src' can only be used as a for source"]),
     ]);
 }

plum-checker/tests/inline_variants_tests.rs CHANGED Viewed

@@ -90,7 +90,7 @@ fn explicit_type_args() {
 fn generic_and_nested_construction() {
     ok("fun cons(h: T, t: Link[T]) -> Link[T] =\n  Cons(head: h, tail: t)");
     ok("fun mk() -> Link[Int] =\n  Cons(head: 1, tail: Cons(head: 2, tail: Nil))");
-    ok("fun mk() -> List[Link[Int]] =\n  List(Cons(head: 1, tail: Nil), Nil)\n\nfun pick(b: Bool) -> Link[Int] =\n  if b\n    Cons(head: 1, tail: Nil)\n  else\n    Nil");
+    ok("fun mk() -> Slice[Link[Int]] =\n  Slice(Cons(head: 1, tail: Nil), Nil)\n\nfun pick(b: Bool) -> Link[Int] =\n  if b\n    Cons(head: 1, tail: Nil)\n  else\n    Nil");
 }
 #[test]

plum-checker/tests/ownership_flow_test.rs CHANGED Viewed

@@ -135,19 +135,19 @@ fn embedding_own_makes_host_own() {
 #[test]
 fn list_copy_of_own_rejected() {
-    let t = texts("fun main(xs: List[Sprite], ys: List[Sprite]) =\n  ys.push(xs.at(0))\n");
+    let t = texts("fun main(xs: Slice[Sprite], ys: Slice[Sprite]) =\n  ys.push(xs.at(0))\n");
     assert!(
         t.iter().any(|m| m.starts_with("cannot store borrowed \"xs.at")),
         "{t:?}"
     );
     let t = texts(
-        "fun main(xs: List[Sprite], ys: List[Sprite]) =\n  s := xs.at(0)\n  ys.push(s)\n",
+        "fun main(xs: Slice[Sprite], ys: Slice[Sprite]) =\n  s := xs.at(0)\n  ys.push(s)\n",
     );
     assert!(
         t.iter().any(|m| m.starts_with("cannot store borrowed \"s\"")),
         "{t:?}"
     );
-    let ok = texts("fun main(xs: List[Sprite]) -> Float =\n  xs.at(0).x\n");
+    let ok = texts("fun main(xs: Slice[Sprite]) -> Float =\n  xs.at(0).x\n");
     assert!(ok.is_empty(), "{ok:?}");
 }
@@ -335,7 +335,7 @@ fn own_trait_field_write_on_own_self_ok() {
 }
 const HANDLED: &str = "\
-own record Handled(actor: Sprite, events: List[Sprite]) =
+own record Handled(actor: Sprite, events: Slice[Sprite]) =
   fun intoActor(own self) -> Sprite =
     match self
       Handled(a, _) => a
@@ -350,7 +350,7 @@ fn match_own_scrutinee_moves_out_ok() {
 #[test]
 fn match_own_scrutinee_then_use_rejected() {
     let t = texts(
-        "own record Handled(actor: Sprite, events: List[Sprite])\n\nfun main(own h: Handled) -> List[Sprite] =\n  match h\n    Handled(a, _) => take(a)\n  h.events\n",
+        "own record Handled(actor: Sprite, events: Slice[Sprite])\n\nfun main(own h: Handled) -> Slice[Sprite] =\n  match h\n    Handled(a, _) => take(a)\n  h.events\n",
     );
     assert!(hasMoved(&t, "h"), "{t:?}");
 }
@@ -358,11 +358,11 @@ fn match_own_scrutinee_then_use_rejected() {
 #[test]
 fn match_borrowed_scrutinee_store_rejected() {
     let t = texts(
-        "own record Handled(actor: Sprite, events: List[Sprite])\n\nfun main(h: Handled, xs: List[Sprite]) =\n  match h\n    Handled(a, _) => xs.push(a)\n",
+        "own record Handled(actor: Sprite, events: Slice[Sprite])\n\nfun main(h: Handled, xs: Slice[Sprite]) =\n  match h\n    Handled(a, _) => xs.push(a)\n",
     );
     assert!(t.iter().any(|m| m.starts_with("cannot store borrowed \"a\"")), "{t:?}");
     let ok = texts(
-        "own record Handled(actor: Sprite, events: List[Sprite])\n\nfun main(h: Handled) -> Float =\n  match h\n    Handled(a, _) => a.x\n",
+        "own record Handled(actor: Sprite, events: Slice[Sprite])\n\nfun main(h: Handled) -> Float =\n  match h\n    Handled(a, _) => a.x\n",
     );
     assert!(ok.is_empty(), "{ok:?}");
 }
@@ -370,7 +370,15 @@ fn match_borrowed_scrutinee_store_rejected() {
 #[test]
 fn match_pattern_name_use_after_move() {
     let t = texts(
-        "own record Handled(actor: Sprite, events: List[Sprite])\n\nfun main(own h: Handled) -> Float =\n  match h\n    Handled(a, _) =>\n      t := take(a)\n      a.x\n",
+        "own record Handled(actor: Sprite, events: Slice[Sprite])\n\nfun main(own h: Handled) -> Float =\n  match h\n    Handled(a, _) =>\n      t := take(a)\n      a.x\n",
     );
     assert!(hasMoved(&t, "a"), "{t:?}");
 }
+#[test]
+fn own_union_member_use_after_move() {
+    let t = texts_raw(
+        "own record Token(id: Int)\nown record Stamp(id: Int)\nenum Mark = Token | Stamp\n\nfun takeMark(own m: Mark) -> Mark = m\n\nfun main() -> Int =\n  t := Token(id: 3)\n  m: Mark := takeMark(t)\n  t.id\n",
+    );
+    assert!(hasMoved(&t, "t"), "{t:?}");
+}

plum-checker/tests/ownership_moves_test.rs CHANGED Viewed

@@ -89,7 +89,7 @@ fn borrow_reads_do_not_move() {
 #[test]
 fn store_borrow_rejected() {
-    let t = texts("fun keep(s: Sprite, xs: List[Sprite]) =\n  xs.push(s)\n");
+    let t = texts("fun keep(s: Sprite, xs: Slice[Sprite]) =\n  xs.push(s)\n");
     assert!(
         t.contains(&"cannot store borrowed \"s\"; pass it with own or move it".to_string()),
         "{t:?}"

plum-checker/tests/types_tests.rs CHANGED Viewed

@@ -10,12 +10,12 @@ fn pinned_a(t: plum_checker::types::PlumType) -> plum_checker::types::PlumType {
 #[test]
 fn substitute_nested() {
-    let ty = TApp("List".into(), vec![pinned_a(TParam("T".into()))]);
+    let ty = TApp("Slice".into(), vec![pinned_a(TParam("T".into()))]);
     let mut s = BTreeMap::new();
     s.insert("T".to_string(), TInt);
     let out = substitute(&ty, &s);
-    assert_eq!(out.to_string(), "List[error{A}!Int]");
+    assert_eq!(out.to_string(), "Slice[error{A}!Int]");
-    assert_eq!(out, TApp("List".into(), vec![pinned_a(TInt)]));
+    assert_eq!(out, TApp("Slice".into(), vec![pinned_a(TInt)]));
 }
 #[test]
@@ -45,10 +45,10 @@ fn display_round_trips() {
             "Map".into(),
             vec![
                 plum_checker::types::strType(),
-                TApp("List".into(), vec![TInt])
+                TApp("Slice".into(), vec![TInt])
             ]
         )
         .to_string(),
-        "Map[Str, List[Int]]"
+        "Map[Str, Slice[Int]]"
     );
 }

plum-checker/tests/unions_tests.rs CHANGED Viewed

@@ -317,7 +317,7 @@ fn rejects_bad_member_coercions() {
         (COERCE, "fun mk() -> Shape =\n  Oval(a: 1.0)", &["expected Shape, found Oval"]),
         (COERCE, "fun take(s: Shape) -> Int =\n  1\n\nfun go() -> Int =\n  take(Oval(a: 1.0))", &["expected Shape, found Oval"]),
         (COERCE, "fun take(s: Shape) -> Int =\n  1\n\nfun go() -> Int =\n  take(\"x\")", &["expected Shape, found Str"]),
-        (COERCE, "fun take(xs: List[Shape]) -> Int =\n  1\n\nfun go(cs: List[Circle]) -> Int =\n  take(cs)", &["expected List[Shape], found List[Circle]"]),
+        (COERCE, "fun take(xs: Slice[Shape]) -> Int =\n  1\n\nfun go(cs: Slice[Circle]) -> Int =\n  take(cs)", &["expected Slice[Shape], found Slice[Circle]"]),
         // annotated declarations
         (COERCE, "fun go() -> Int =\n  s: Int := \"x\"\n  1", &["assign 's'", "mismatch"]),
         (COERCE, "fun go() -> Int =\n  s: Shape = Circle(r: 1.0)\n  1", &["annotated declarations use :="]),

plum-core/src/forms.rs CHANGED Viewed

@@ -17,6 +17,8 @@
 //!   expression is the value of the `yield`.
 //! * `for k, v := range xs` where the type of `xs` declares `fun* entries(self)`: the
 //!   same as `for k, v := range xs.entries()`.
+//! * `for x := range xs` where the type of `xs` declares `fun* items(self)` (std `List`,
+//!   whose `at(i)` is O(n)): the same as `for x := range xs.items()`.
 //! * anything else: plain iteration over `length()` / `at(i)`, lowered to a
 //!   `while` loop; with two binders they are `(position, element)`.
 //!
@@ -213,7 +215,7 @@ pub fn prepareForms(source: &mut Source) {
 }
 /// The check copy of an `extend Seq[T]` method: a free fn whose first parameter
-/// `self` is a `List[T]` standing for the sequence.
+/// `self` is a `Slice[T]` standing for the sequence.
 fn seqCheckCopy(f: &Fn) -> Fn {
     let mut c = f.clone();
     c.name = format!("{}_{}", SEQ, f.name);
@@ -224,7 +226,7 @@ fn seqCheckCopy(f: &Fn) -> Fn {
 isOwn: false,
             name: "self".to_string(),
             ty: ParamType::Type(Type {
-                name: "List".to_string(),
+                name: "Slice".to_string(),
                 generics: vec![Type {
                     name: "T".to_string(),
                     generics: vec![],
@@ -789,10 +791,14 @@ impl Lowerer<'_> {
             }
             _ => {}
         }
+        if self.fatal {
+            return None;
+        }
-        if fl.binders.len() == 2 && !self.reg.methodNames.is_empty() {
+        if matches!(fl.binders.len(), 1 | 2) && !self.reg.methodNames.is_empty() {
+            let want = if fl.binders.len() == 2 { "entries" } else { "items" };
             match (self.typeOf)(&fl.source) {
                 Some(ti) => {
-                    if let Some(f) = self.reg.methods.get(&(ti.name, "entries".to_string())) {
+                    if let Some(f) = self.reg.methods.get(&(ti.name, want.to_string())) {
                         return Some((f.clone(), Some(fl.source.clone()), vec![]));
                     }
                 }
@@ -1799,7 +1805,7 @@ fn checkCopy(f: &Fn) -> Fn {
     for p in &mut c.params {
         if let ParamType::Seq(t) = &p.ty {
             p.ty = ParamType::Type(Type {
-                name: "List".to_string(),
+                name: "Slice".to_string(),
                 generics: vec![t.clone()],
             });
         }

plum-core/src/loader.rs CHANGED Viewed

@@ -101,7 +101,7 @@ pub fn loadAndMergeWithOverrides(
     Ok(merged)
 }
-/// A std `primitive List[T] =` (any non-built-in name that is also a declared
+/// A std `primitive Slice[T] =` (any non-built-in name that is also a declared
 /// enum/record) is an EXTENSION: its `fun`s are methods of that type (a
 /// duplicate method name is already a collision error) and it is not a
 /// stateless namespace, so it leaves the namespace list. Outside std this

plum-core/tests/formatter_test.rs CHANGED Viewed

@@ -199,10 +199,10 @@ fn formatsErrorSyntax() {
 #[test]
 fn formatsTypeSugar() {
-    let input = "fun f(a: Person?,b: Int?) -> List[Int?] =\n  a\n";
+    let input = "fun f(a: Person?,b: Int?) -> Slice[Int?] =\n  a\n";
     let first = formatSource(input).expect("formatSource should succeed");
     assert!(first.contains("a: Person?, b: Int?"), "{first}");
-    assert!(first.contains("-> List[Int?] ="), "{first}");
+    assert!(first.contains("-> Slice[Int?] ="), "{first}");
     assert_eq!(
         first,
         formatSource(&first).expect("second pass"),
@@ -251,8 +251,8 @@ fn formatsZigStyleErrors() {
     assert!(out.contains("y := h(s) catch e\n    return 0"), "{out}");
     assert!(out.contains("  return error.Bad"), "{out}");
     assert_eq!(formatSource(&out).expect("second"), out, "idempotent");
-    let g = formatSource("fun f() -> !List[Int] =\n  return error.A\n").expect("format");
+    let g = formatSource("fun f() -> !Slice[Int] =\n  return error.A\n").expect("format");
-    assert!(g.contains("-> !List[Int] ="), "{g}");
+    assert!(g.contains("-> !Slice[Int] ="), "{g}");
     let h = formatSource(
         "error  ParseError=A|B\n\nfun f() -> (ParseError||error{ C,D })!Int =\n  return error.A\n",
     )
@@ -296,23 +296,23 @@ fn formatOneLineEnum() {
     );
     let second = formatSource(&first).expect("second");
     assert_eq!(first, second);
-    let g = formatSource("enum Js = JsNull | List[Js] | Map[Str, Js]\n").expect("format");
+    let g = formatSource("enum Js = JsNull | Slice[Js] | Map[Str, Js]\n").expect("format");
     assert!(
-        g.contains("enum Js = JsNull | List[Js] | Map[Str, Js]\n"),
+        g.contains("enum Js = JsNull | Slice[Js] | Map[Str, Js]\n"),
         "got: {g:?}"
     );
 }
 #[test]
 fn formatAnnotatedDeclaration() {
-    let input = "fun main() =\n  s:Shape:=Circle(r: 2.0)\n  xs: List[Shape] := List[Shape]()\n  f:fn(Int)->Int:=twice\n  o: Int? := null\n";
+    let input = "fun main() =\n  s:Shape:=Circle(r: 2.0)\n  xs: Slice[Shape] := Slice[Shape]()\n  f:fn(Int)->Int:=twice\n  o: Int? := null\n";
     let first = formatSource(input).expect("format");
     assert!(
         first.contains("  s: Shape := Circle(r: 2.0)\n"),
         "got: {first:?}"
     );
     assert!(
-        first.contains("  xs: List[Shape] := List[Shape]()\n"),
+        first.contains("  xs: Slice[Shape] := Slice[Shape]()\n"),
         "got: {first:?}"
     );
     assert!(

plum-core/tests/inline_variants_test.rs CHANGED Viewed

@@ -110,7 +110,7 @@ fn type_position_errors() {
         "fun fa(cc: Cons[Int]) -> Int = 1\n",
         "fun fa() -> Cons[Int] = todo\n",
         "record Box(cc: Cons[Int])\n",
-        "fun fa(cc: List[Cons[Int]]) -> Int = 1\n",
+        "fun fa(cc: Slice[Cons[Int]]) -> Int = 1\n",
         "fun fa(gg: fn(Cons[Int]) -> Int) -> Int = 1\n",
         "fun fa() -> Int =\n  cc: Cons[Int] := todo\n  1\n",
     ] {

plum-core/tests/parser_test.rs CHANGED Viewed

@@ -347,13 +347,13 @@ fn nullable_sugar_parses_to_pinned_null_error_union() {
 #[test]
 fn nested_nullable_generic_argument() {
-    let source = parse("fun f() -> List[Int?] =\n  1\n");
+    let source = parse("fun f() -> Slice[Int?] =\n  1\n");
     let f = onlyFn(&source);
     let inner = ty(
         "!",
         vec![ty("Int", vec![]), ty("error", vec![ty("null", vec![])])],
     );
-    assert_eq!(f.returns, Some(ty("List", vec![inner])));
+    assert_eq!(f.returns, Some(ty("Slice", vec![inner])));
 }
 #[test]
@@ -417,9 +417,9 @@ fn error_union_type_inferred_and_pinned() {
         .map(|g| g.name.as_str())
         .collect();
     assert_eq!(names, ["BadNumStr", "Other"]);
-    let t = retType("fun f() -> !List[Int] =\n  1\n");
+    let t = retType("fun f() -> !Slice[Int] =\n  1\n");
     assert_eq!(t.generics.len(), 1);
-    assert_eq!(t.generics[0].name, "List");
+    assert_eq!(t.generics[0].name, "Slice");
     assert_eq!(t.generics[0].generics[0].name, "Int");
 }
@@ -955,7 +955,7 @@ fn unionEnumMultiLineGenericMember() {
 #[test]
 fn one_line_generic_member() {
-    let source = parseRaw("enum Js = JsNull | List[Js] | Map[Str, Js]");
+    let source = parseRaw("enum Js = JsNull | Slice[Js] | Map[Str, Js]");
     let e = onlyEnum(&source);
     assert_eq!(memberOf(&e.variants[0]).generics.len(), 0);
     assert_eq!(memberOf(&e.variants[1]).generics.len(), 1);
@@ -996,9 +996,9 @@ fn annotatedDeclarationCarriesItsType() {
 #[test]
 fn annotatedDeclarationTypes() {
-    let a = firstAssign("fun f() =\n  xs: List[Shape] := List[Shape]()\n");
+    let a = firstAssign("fun f() =\n  xs: Slice[Shape] := Slice[Shape]()\n");
     let t = a.ty.unwrap();
-    assert_eq!((t.name.as_str(), t.generics.len()), ("List", 1));
+    assert_eq!((t.name.as_str(), t.generics.len()), ("Slice", 1));
     let a = firstAssign("fun f() =\n  g: fn(Int) -> Int := |n| n + 1\n");
     assert!(a.ty.unwrap().asFn().is_some());
     let a = firstAssign("fun f() =\n  o: Int? := null\n");

plum-core/tests/record_init_test.rs CHANGED Viewed

@@ -124,11 +124,11 @@ fn init_with_params_rejected() {
 fn annotate_error_and_annotation() {
     let (_, e) = lower("record Rec(a: Int) =\n  fun init(self) =\n    self.t = null\n");
     assert!(e.iter().any(|m| m.starts_with("annotate the type: self.t: T = ...")), "{e:?}");
-    let (s, e) = lower("record Rec(a: Int) =\n  fun init(self) =\n    self.t: Int? = null\n    self.l = List[Int]()\n    self.s = \"x\"\n    self.b = true\n");
+    let (s, e) = lower("record Rec(a: Int) =\n  fun init(self) =\n    self.t: Int? = null\n    self.l = Slice[Int]()\n    self.s = \"x\"\n    self.b = true\n");
     assert!(e.is_empty(), "{e:?}");
     let v = &enumOf(&s, "Rec").variants[0];
     assert_eq!(v.field_names, vec!["a", "t", "l", "s", "b"]);
-    assert_eq!(v.fields[2].name, "List");
+    assert_eq!(v.fields[2].name, "Slice");
     assert_eq!(v.fields[3].name, "Str");
     assert_eq!(v.fields[4].name, "Bool");
 }

plum-core/tests/traits_test.rs CHANGED Viewed

@@ -140,10 +140,10 @@ fn struct_embed() {
 #[test]
 fn self_recursive_field() {
-    let mut s = parseRaw("trait Act(children: List[Act])\nrecord Nod(Act)\n");
+    let mut s = parseRaw("trait Act(children: Slice[Act])\nrecord Nod(Act)\n");
     assert!(lowerTraits(&mut s).is_empty());
     let t = &enumOf(&s, "Nod").variants[0].fields[0];
-    assert_eq!(t.name, "List");
+    assert_eq!(t.name, "Slice");
     assert_eq!(t.generics[0].name, "Act");
 }

plum-core/tests/trmc_test.rs CHANGED Viewed

@@ -303,9 +303,9 @@ fn structNewCount(wasm: &[u8], name: &str) -> usize {
 fn map_single_pass_one_alloc_per_cell() {
     let p = prog("fun main() -> Int = count(map(fromTo(0, 3), |x| x + 1))\n");
     let bytes = compileSource(&load("single", &p)).unwrap();
-    // One record + its wrapper variant per cell, in one loop (two loops before).
+    // One struct.new per cell (the member is the enum subtype), in one loop.
-    assert_eq!(structNewCount(&bytes, "map"), 2);
+    assert_eq!(structNewCount(&bytes, "map"), 1);
-    assert_eq!(structNewCount(&bytes, "fromTo"), 2);
+    assert_eq!(structNewCount(&bytes, "fromTo"), 1);
 }
 #[test]

plum-core/tests/union_lower_test.rs CHANGED Viewed

@@ -468,7 +468,7 @@ fn narrow_does_not_leak_into_later_items() {
 #[test]
 fn narrow_for_clause_bind_shadows() {
     let mut s = parse(
-        "fun f(s: Shape, xs: List[Int]) =\n  match s\n    Circle =>\n      for s := range xs\n        s.r\n",
+        "fun f(s: Shape, xs: Slice[Int]) =\n  match s\n    Circle =>\n      for s := range xs\n        s.r\n",
     );
     let plan = narrowPlan(&s, "f", "s", "Shape__Circle", "s__n1");
     applyPlan(&mut s, &plan);

plum-core/tests/unions_test.rs CHANGED Viewed

@@ -78,10 +78,10 @@ fn recordsOtherKinds() {
 #[test]
 fn dup_base_name() {
-    let mut s = parse("struct List(n: Int)\nenum Js = List[Int] | List[Str]");
+    let mut s = parse("struct Slice(n: Int)\nenum Js = Slice[Int] | Slice[Str]");
     assert_eq!(
         resolveMembers(&mut s),
-        vec!["enum Js has two List members; a pattern 'List' would be ambiguous"]
+        vec!["enum Js has two Slice members; a pattern 'Slice' would be ambiguous"]
     );
 }

plum-examples/annotated_locals.plum CHANGED Viewed

@@ -6,7 +6,7 @@ module annotated_locals
 import std/Str
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 record Circle(r: Float)
@@ -52,7 +52,7 @@ test "optional_local_null"
   assert {o ?: 9} == 5
 test "list_local"
-  xs: List[Shape] := List[Shape]()
+  xs: Slice[Shape] := Slice[Shape]()
   xs.push(Circle(r: 1.0))
   xs.push(Rect(w: 1.0, h: 1.0))
   assert xs.length() == 2

plum-examples/cons_list.plum ADDED Viewed

@@ -0,0 +1,70 @@
+# The std cons List: constant stack at 1,000,000 elements.
+module cons_list
+import std/Int
+import std/Str
+import std/Slice
+import std/Array
+import std/List
+fun range(a: Int, b: Int) -> List[Int] =
+  if a >= b then Nil else Cons(head: a, tail: range(a + 1, b))
+test "init_sum"
+  assert List(1, 2, 3, 4).fold(0, |a, x| a + x) == 10
+  assert List(1, 2, 3).length() == 3
+  assert { List(1, 2, 3).get(1) ?: -1 } == 2
+  assert List(1, 2, 3).get(5) == null
+  nil: List[Int] := Nil
+  assert nil.isEmpty()
+  assert !List(1).isEmpty()
+test "map_filter_fold"
+  xs := List(1, 2, 3, 4, 5, 6)
+  ys := xs.map(|x| x * 2).filter(|x| x % 3 == 0)
+  assert ys.length() == 2
+  assert ys.fold(0, |a, x| a + x) == 18
+test "reverse_append"
+  xs := List(1, 2, 3).reverse()
+  assert { xs.get(0) ?: -1 } == 3
+  assert { xs.get(2) ?: -1 } == 1
+  ys := List(1, 2).append(List(3, 4))
+  assert ys.equals(List(1, 2, 3, 4))
+test "for_range"
+  total := 0
+  for x := range List(1, 2, 3, 4)
+    total = total + x
+  assert total == 10
+  big := 0
+  for x := range range(0, 1000000).items()
+    big = big + x
+  assert big == 499999500000
+test "to_slice_round_trip"
+  s := List(1, 2, 3).map(|x| x * 2).toSlice()
+  assert s.equals(Slice(2, 4, 6))
+  assert List.fromSlice(s).equals(List(2, 4, 6))
+test "to_array"
+  a := List(7, 8, 9).toArray()
+  assert a.length() == 3
+  assert a.get(2) == 9
+test "map_million"
+  ys := range(0, 1000000).map(|x| x + 1)
+  assert ys.length() == 1000000
+  assert ys.fold(0, |a, x| a + x) == 500000500000
+test "fold_million"
+  xs := range(0, 1000000)
+  assert xs.fold(0, |a, x| a + x) == 499999500000
+  assert xs.filter(|x| x % 2 == 0).length() == 500000
+  assert { xs.reverse().get(0) ?: -1 } == 999999
+test "equals_and_toStr"
+  assert List(1, 2, 3).equals(List(1, 2, 3))
+  assert !List(1, 2, 3).equals(List(1, 2))
+  assert !List(1, 2).equals(List(1, 2, 3))
+  assert !List(1, 2, 3).equals(List(1, 2, 4))
+  assert List(1, 2, 3).toStr() == "[1,2,3]"

plum-examples/constants.plum CHANGED Viewed

@@ -2,7 +2,7 @@ module constants
 import std/Int
 import std/Float
 import std/Str
-import std/List
+import std/Slice
 # Constants and static functions live inside a type's body or a `primitive`
 # namespace — there are no top-level constants. `Name = expr` declares an
@@ -42,7 +42,7 @@ fun scaled(n: Float) -> Float = n * Grid.CellScale
 primitive Shelf =
   Sides = 4
-  Names = List("a", "b", "c")
+  Names = Slice("a", "b", "c")
   fun sidesTwice() -> Int =
     twice(Shelf.Sides)

plum-examples/error_propagation.plum CHANGED Viewed

@@ -1,7 +1,7 @@
 import std/Int
 import std/Float
 import std/Str
-import std/List
+import std/Slice
 import std/Map
 # `!T` is "a `T` or an error". An error is a value written `error.Name` (for
@@ -46,7 +46,7 @@ fun sumTwo(a: Str, b: Str) -> !Int =
 # Two calls with different error sets merge into [BadNumStr, OutOfBounds].
 fun numAt(s: Str, i: Int) -> error{BadNumStr, OutOfBounds}!Int =
   n := try Int.parse(s)
-  xs := List(10, 20, 30)
+  xs := Slice(10, 20, 30)
   x := try xs.get(i)
   n + x
@@ -55,7 +55,7 @@ fun parseOrInvalid(s: Str) -> error{InvalidInput}!Int =
   n := Int.parse(s) catch return error.InvalidInput
   n
-fun doubledFirst(list: List[Int]) -> error{ListWasEmpty}!Int =
+fun doubledFirst(list: Slice[Int]) -> error{ListWasEmpty}!Int =
   a := try list.first()
   a * 2
@@ -64,7 +64,7 @@ fun sumOrZero(a: Str, b: Str) -> Int =
   y := {parsePositive(b) catch 0}
   x + y
-fun firstOrDefault(list: List[Int], default: Int) -> Int =
+fun firstOrDefault(list: Slice[Int], default: Int) -> Int =
   {list.first() catch default}
 fun mustBePositive(n: Int) -> Int =
@@ -148,15 +148,15 @@ record Age(n: Int) =
     n := try parsePositive(s)
     return Age(n)
-record Ages[T](items: List[T]) =
+record Ages[T](items: Slice[T]) =
-  fun parseAll(xs: List[Str]) -> !Ages[T] =
+  fun parseAll(xs: Slice[Str]) -> !Ages[T] =
-    out := List[T]()
+    out := Slice[T]()
     for x := range xs
       v := try T.parse(x)
       out.push(v)
     return Ages(out)
-fun parseAges(xs: List[Str]) -> !Ages[Age] = Ages.parseAll(xs)
+fun parseAges(xs: Slice[Str]) -> !Ages[Age] = Ages.parseAll(xs)
 test "try operator unwraps the value and propagates it through two calls"
   assert sumTwo("2", "3")! == 5
@@ -183,25 +183,25 @@ test "catch return error.X maps the error to another name"
   assert name == 0
 test "try binds a declaration from a type parameter's static method in a loop"
-  ages := parseAges(List("3", "4"))!
+  ages := parseAges(Slice("3", "4"))!
   assert ages.items.length() == 2
   assert ages.items.get(1)!.n == 4
-  failed := parseAges(List("3", "-1")) catch e
+  failed := parseAges(Slice("3", "-1")) catch e
     assert e.name() == "NegativeNum"
-    Ages(List[Age]())
+    Ages(Slice[Age]())
   assert failed.items.length() == 0
 test "try operator on a list that is empty yields ListWasEmpty"
-  assert doubledFirst(List(5))! == 10
+  assert doubledFirst(Slice(5))! == 10
-  assert {doubledFirst(List[Int]()) catch -1} == -1
+  assert {doubledFirst(Slice[Int]()) catch -1} == -1
 test "catch default unwraps the value and falls back to 0 on an error"
   assert sumOrZero("2", "3") == 5
   assert sumOrZero("2", "-3") == 2
 test "catch default falls back to the given default on an empty list"
-  assert firstOrDefault(List(5), 99) == 5
+  assert firstOrDefault(Slice(5), 99) == 5
-  assert firstOrDefault(List[Int](), 99) == 99
+  assert firstOrDefault(Slice[Int](), 99) == 99
 test "crash is not reached on the happy path"
   assert mustBePositive(3) == 3
@@ -226,10 +226,10 @@ test "match falls back to a wildcard arm"
   assert ageOrDefault("999") == 150
   assert ageOrDefault("x") == 0
-# An error union can be the success type of another (a `List[!Int]` holds
+# An error union can be the success type of another (a `Slice[!Int]` holds
 # per-element results): `xs.get(i)` is `!!Int`, unwrapped one level at a time.
 test "a list of error unions nests one level per access"
-  results := List(parsePositive("1"), parsePositive("-1"), parsePositive("x"))
+  results := Slice(parsePositive("1"), parsePositive("-1"), parsePositive("x"))
   first := results.get(0)!
   assert first! == 1
   second := results.get(1)!

plum-examples/forms.plum CHANGED Viewed

@@ -3,7 +3,7 @@
 import std/Str
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 import std/Testing
 import std/Seq
@@ -14,11 +14,11 @@ import std/Seq
 record Fighter(name: Str, hp: Int, dead: Bool)
-fun sampleFighters() -> List[Fighter] =
+fun sampleFighters() -> Slice[Fighter] =
-  List(Fighter(name: "a", hp: 10, dead: false), Fighter(name: "b", hp: 0, dead: true), Fighter(name: "c", hp: 7, dead: false))
+  Slice(Fighter(name: "a", hp: 10, dead: false), Fighter(name: "b", hp: 0, dead: true), Fighter(name: "c", hp: 7, dead: false))
 # a user form: the sum of the body's value over a list
-fun* sumBy(xs: List[T]) *T -> Int =
+fun* sumBy(xs: Slice[T]) *T -> Int =
   total := 0
   for x := range xs
     v := yield x
@@ -33,24 +33,24 @@ fun* neighbours(x: Int, y: Int) *(Int, Int) =
         yield x + dx - 1, y + dy - 1
 # a user form built from another form: `yield` sits inside `each`'s body
-fun* sumEvens(xs: List[Int]) *Int -> Int =
+fun* sumEvens(xs: Slice[Int]) *Int -> Int =
   total := 0
   for x := range xs.each(), if x % 2 == 0
     v := yield x
     total = total + v
   total
-fun firstBig(xs: List[Int]) -> Int =
+fun firstBig(xs: Slice[Int]) -> Int =
   for x := range xs.each()
     if x > 10
       return x
   return -1
-fun returnedForm(xs: List[Int]) -> List[Int] =
+fun returnedForm(xs: Slice[Int]) -> Slice[Int] =
   return for x := range xs.map()
     x + 1
-fun tailForm(xs: List[Int]) -> Int =
+fun tailForm(xs: Slice[Int]) -> Int =
   for x := range sumBy(xs)
     x * 2
@@ -78,7 +78,7 @@ test "user_form_sumBy"
   hp := for u := range sumBy(fighters)
     u.hp
   assert hp == 17
-  odd := for x := range sumBy(List(1, 2, 3, 4, 5)), if x % 2 == 1
+  odd := for x := range sumBy(Slice(1, 2, 3, 4, 5)), if x % 2 == 1
     x
   assert odd == 9
@@ -92,7 +92,7 @@ test "user_form_neighbours_grid: two binders, statement body"
   assert sum == 15
 test "break_continue_return_semantics"
-  xs := List(1, 2, 3, 4, 5)
+  xs := Slice(1, 2, 3, 4, 5)
   total := 0
   for x := range xs.each()
     if x == 2
@@ -101,7 +101,7 @@ test "break_continue_return_semantics"
       break
     total = total + x
   assert total == 8
-  assert firstBig(List(1, 20, 30)) == 20
+  assert firstBig(Slice(1, 20, 30)) == 20
   assert firstBig(xs) == -1
   prefix := for x := range xs.filter()
     if x == 4
@@ -110,14 +110,14 @@ test "break_continue_return_semantics"
   assert prefix.length() == 2
 test "composed form: a form that uses another form"
-  xs := List(1, 2, 3, 4, 5, 6)
+  xs := Slice(1, 2, 3, 4, 5, 6)
   total := for x := range sumEvens(xs)
     x * 10
   assert total == 120
 test "forms nest: a form inside a form body"
-  xs := List(1, 2)
+  xs := Slice(1, 2)
-  ys := List(10, 20)
+  ys := Slice(10, 20)
   total := for a := range sumBy(xs)
     inner := for b := range sumBy(ys)
       a * b
@@ -125,12 +125,12 @@ test "forms nest: a form inside a form body"
   assert total == 90
 test "return for-form: the form's value is returned"
-  ys := returnedForm(List(1, 2, 3))
+  ys := returnedForm(Slice(1, 2, 3))
   assert ys.length() == 3
   assert ys.at(2) == 4
 test "tail for-form: the last statement of a fn is its value"
-  assert tailForm(List(1, 2, 3)) == 12
+  assert tailForm(Slice(1, 2, 3)) == 12
 test "fun_star_method_uses_self"
   c := Countdown(from: 4)

plum-examples/functional.plum CHANGED Viewed

@@ -2,18 +2,18 @@
 #
 # Everything here is a value: nothing is mutated after it is built. Data is made
 # of recursive sum types (`enum`) whose variants are declared inline with named
-# fields, `Cons(head: T, tail: Link[T])`. A variant is a constructor and a
+# fields, `Link(head: T, tail: Chain[T])`. A variant is a constructor and a
-# pattern only; `Link[T]` is the only type, and fields are read by matching.
+# pattern only; `Chain[T]` is the only type, and fields are read by matching.
 # Every operation is a method on its enum, a recursive function whose body is
 # `= match self` with the arms indented below, returning a new value. Unchanged
 # parts are shared.
 #
-#   1. Link[T]: a cons list (`Nil` or `Cons(head, tail)`), combinators as methods on the enum
+#   1. Chain[T]: a cons list (`Empty` or `Link(head, tail)`), combinators as methods on the enum
 #   2. Functions as values: closures, composition, currying, pipelines
 #   3. Tree: a persistent binary search tree, operations as methods on the enum
 #   4. Pattern matching: nested patterns, guards, pattern `if`, optionals
 #   5. A pure scene graph: a recursive `Node` tree whose groups hold a
-#      `Link[Node]` of children; acting, drawing, hit testing and event routing
+#      `Chain[Node]` of children; acting, drawing, hit testing and event routing
 #      are all methods from an old tree to a new one
 #
 #   6. Loops, functionally: the same job as methods, a `for` and a `while`
@@ -24,29 +24,30 @@ module functional
 import std/Str
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 # ---------------------------------------------------------------------------
-# 1. Link[T]: a cons list
+# 1. Chain[T]: a cons list (std/List is the same shape, with variants Nil and Cons;
+# renamed here to Empty and Link only so this file can define its own)
 # ---------------------------------------------------------------------------
-# A list is either empty (`Nil`, a tag) or a head value in front of another list.
+# A list is either empty (`Empty`, a tag) or a head value in front of another list.
 # Its operations are methods on the enum.
-enum Link[T] =
+enum Chain[T] =
-  | Nil
+  | Empty
-  | Cons(head: T, tail: Link[T])
+  | Link(head: T, tail: Chain[T])
   fun length(self) -> Int = match self
-    Nil => 0
+    Empty => 0
-    Cons(_, t) => 1 + t.length()
+    Link(_, t) => 1 + t.length()
   fun isEmpty(self) -> Bool = match self
-    Nil => true
+    Empty => true
-    Cons(_, _) => false
+    Link(_, _) => false
   # Runs `f` on every element, in order, for its effect.
   fun each(self, f: fn(T)) -> Unit =
-    if Cons(h, t) := self
+    if Link(h, t) := self
       f(h)
       t.each(f)
@@ -54,89 +55,89 @@ enum Link[T] =
   fun* items(self) *T =
     cur := self
     while true
-      if Cons(h, t) := cur
+      if Link(h, t) := cur
         cur = t
         yield h
       else
         break
   # Structural recursion: rebuild the list with `f` applied to every element.
-  fun map(self, f: fn(T) -> B) -> Link[B] = match self
+  fun map(self, f: fn(T) -> B) -> Chain[B] = match self
-    Nil => Nil
+    Empty => Empty
-    Cons(h, t) => Cons(head: f(h), tail: t.map(f))
+    Link(h, t) => Link(head: f(h), tail: t.map(f))
-  fun filter(self, keep: fn(T) -> Bool) -> Link[T] = match self
+  fun filter(self, keep: fn(T) -> Bool) -> Chain[T] = match self
-    Nil => Nil
+    Empty => Empty
-    Cons(h, t) =>
+    Link(h, t) =>
       rest := t.filter(keep)
       if keep(h) then cons(h, rest) else rest
   # Left fold: `f(f(f(acc, x0), x1), x2)`. Tail recursive in shape.
   fun foldl(self, acc: A, f: fn(A, T) -> A) -> A = match self
-    Nil => acc
+    Empty => acc
-    Cons(h, t) => t.foldl(f(acc, h), f)
+    Link(h, t) => t.foldl(f(acc, h), f)
   # Right fold: `f(x0, f(x1, f(x2, acc)))`. Keeps the list's order when rebuilding.
   fun foldr(self, acc: A, f: fn(T, A) -> A) -> A = match self
-    Nil => acc
+    Empty => acc
-    Cons(h, t) => f(h, t.foldr(acc, f))
+    Link(h, t) => f(h, t.foldr(acc, f))
-  fun reverse(self) -> Link[T] =
+  fun reverse(self) -> Chain[T] =
-    self.foldl(Nil, |acc, x| cons(x, acc))
+    self.foldl(Empty, |acc, x| cons(x, acc))
   # `self` followed by `ys`. Only `self` is rebuilt; `ys` is shared.
-  fun append(self, ys: Link[T]) -> Link[T] =
+  fun append(self, ys: Chain[T]) -> Chain[T] =
     self.foldr(ys, |x, acc| cons(x, acc))
   fun any(self, p: fn(T) -> Bool) -> Bool = match self
-    Nil => false
+    Empty => false
-    Cons(h, t) => p(h) || t.any(p)
+    Link(h, t) => p(h) || t.any(p)
   fun all(self, p: fn(T) -> Bool) -> Bool = match self
-    Nil => true
+    Empty => true
-    Cons(h, t) => p(h) && t.all(p)
+    Link(h, t) => p(h) && t.all(p)
-  fun take(self, n: Int) -> Link[T] = match self
+  fun take(self, n: Int) -> Chain[T] = match self
-    Nil => Nil
+    Empty => Empty
-    Cons(h, t) => if n <= 0 then Nil else cons(h, t.take(n - 1))
+    Link(h, t) => if n <= 0 then Empty else cons(h, t.take(n - 1))
-  fun drop(self, n: Int) -> Link[T] = match self
+  fun drop(self, n: Int) -> Chain[T] = match self
-    Nil => Nil
+    Empty => Empty
-    Cons(_, t) => if n <= 0 then self else t.drop(n - 1)
+    Link(_, t) => if n <= 0 then self else t.drop(n - 1)
   # The first element, or null for an empty list.
   fun first(self) -> T? = match self
-    Nil => null
+    Empty => null
-    Cons(h, _) => h
+    Link(h, _) => h
   # Pairs up two lists, stopping at the shorter one.
-  fun zip(self, ys: Link[B]) -> Link[Pair[T, B]] = match self
+  fun zip(self, ys: Chain[B]) -> Chain[Pair[T, B]] = match self
-    Nil => Nil
+    Empty => Empty
-    Cons(x, xt) =>
+    Link(x, xt) =>
       match ys
-        Nil => Nil
+        Empty => Empty
-        Cons(y, yt) => cons(Pair[T, B](fst: x, snd: y), xt.zip(yt))
+        Link(y, yt) => cons(Pair[T, B](fst: x, snd: y), xt.zip(yt))
 record Pair[A, B](fst: A, snd: B)
 # Prepends `h`: O(1), and `t` is shared, not copied.
-fun cons(h: T, t: Link[T]) -> Link[T] = Cons(head: h, tail: t)
+fun cons(h: T, t: Chain[T]) -> Chain[T] = Link(head: h, tail: t)
-fun single(x: T) -> Link[T] = cons(x, Nil)
+fun single(x: T) -> Chain[T] = cons(x, Empty)
 # The integers from `a` up to but not including `b`.
-fun fromTo(a: Int, b: Int) -> Link[Int] =
+fun fromTo(a: Int, b: Int) -> Chain[Int] =
-  if a >= b then Nil else cons(a, fromTo(a + 1, b))
+  if a >= b then Empty else cons(a, fromTo(a + 1, b))
-fun sum(xs: Link[Int]) -> Int =
+fun sum(xs: Chain[Int]) -> Int =
   xs.foldl(0, |a, x| a + x)
-fun joinInts(xs: Link[Int], sep: Str) -> Str = match xs
+fun joinInts(xs: Chain[Int], sep: Str) -> Str = match xs
-  Nil => ""
+  Empty => ""
-  Cons(h, t) =>
+  Link(h, t) =>
     match t
-      Nil => "{h}"
+      Empty => "{h}"
-      Cons(_, _) => "{h}{sep}{joinInts(t, sep)}"
+      Link(_, _) => "{h}{sep}{joinInts(t, sep)}"
 # ---------------------------------------------------------------------------
 # 2. Functions as values
@@ -197,15 +198,15 @@ enum Tree =
     Leaf => acc
     Branch(l, x, r) => l.fold(f(x, r.fold(acc, f)), f)
-  fun inOrder(self) -> Link[Int] =
+  fun inOrder(self) -> Chain[Int] =
-    self.fold(Nil, |x, acc| cons(x, acc))
+    self.fold(Empty, |x, acc| cons(x, acc))
   fun smallest(self) -> Int? = match self
     Leaf => null
     Branch(Leaf, x, _) => x
     Branch(l, _, _) => l.smallest()
-fun fromLink(xs: Link[Int]) -> Tree =
+fun fromLink(xs: Chain[Int]) -> Tree =
   xs.foldl(Leaf, |t, x| t.insert(x))
 # ---------------------------------------------------------------------------
@@ -227,10 +228,10 @@ enum Shape =
     if Rect(w, h) := self, w > h then true else false
 # Nested patterns look two levels into a list.
-fun firstTwo(xs: Link[Int]) -> Str = match xs
+fun firstTwo(xs: Chain[Int]) -> Str = match xs
-  Cons(a, Cons(b, _)) => "{a},{b}"
+  Link(a, Link(b, _)) => "{a},{b}"
-  Cons(a, Nil) => "{a}"
+  Link(a, Empty) => "{a}"
-  Nil => "empty"
+  Empty => "empty"
 # ---------------------------------------------------------------------------
 # 5. A pure scene graph
@@ -267,7 +268,7 @@ enum Node =
   | Sprite(id: Int, xf: Xf, w: Float, h: Float, image: Str, spin: Float)
   | Label(id: Int, xf: Xf, text: Str)
   | Button(id: Int, xf: Xf, w: Float, h: Float, text: Str, pressed: Bool)
-  | Group(id: Int, xf: Xf, children: Link[Node])
+  | Group(id: Int, xf: Xf, children: Chain[Node])
   fun id(self) -> Int = match self
     Sprite(id, _, _, _, _, _) => id
@@ -303,13 +304,13 @@ enum Node =
     _ => self
   # Depth first, parents before children, so later commands draw on top.
-  fun draw(self, parent: Xf) -> Link[DrawCmd] =
+  fun draw(self, parent: Xf) -> Chain[DrawCmd] =
     xf := thenXf(parent, self.xf())
     match self
       Sprite(id, _, _, _, _, _) => single(cmd("sprite", id, xf))
       Label(id, _, _) => single(cmd("label", id, xf))
       Button(id, _, _, _, _, pressed) => single(cmd(if pressed then "button-down" else "button", id, xf))
-      Group(_, _, kids) => kids.foldr(Nil, |k, acc| k.draw(xf).append(acc))
+      Group(_, _, kids) => kids.foldr(Empty, |k, acc| k.draw(xf).append(acc))
   # The id of the topmost node under stage point (px, py), or null. Children drawn
   # later are on top, so they are tried first (in reverse order).
@@ -330,9 +331,9 @@ enum Node =
 fun hitBox(n: Node, p: Pt, w: Float, h: Float) -> Int? =
   if inBox(p, w, h) then n.id() else null
-fun firstHit(kids: Link[Node], xf: Xf, px: Float, py: Float) -> Int? = match kids
+fun firstHit(kids: Chain[Node], xf: Xf, px: Float, py: Float) -> Int? = match kids
-  Nil => null
+  Empty => null
-  Cons(k, rest) =>
+  Link(k, rest) =>
     if hit := k.findHit(xf, px, py)
       hit
     else
@@ -344,13 +345,13 @@ enum UiKind = Clicked | Pressed
 record UiEvent(id: Int, kind: UiKind)
-record Routed(node: Node, events: Link[UiEvent])
+record Routed(node: Node, events: Chain[UiEvent])
 fun click(root: Node, px: Float, py: Float) -> Routed =
   if id := root.findHit(identityXf(), px, py)
     Routed(node: root.update(id, |n| n.press()), events: single(UiEvent(id: id, kind: Clicked)))
   else
-    Routed(node: root, events: Nil)
+    Routed(node: root, events: Empty)
 # A small scene: a group placed at (100, 50) holding a moving ship, a title and a
 # play button inside a nested, half-size menu group.
@@ -368,22 +369,22 @@ fun demoScene() -> Node =
 # One job (the sum of the even numbers), written three ways. They all agree.
 #
 # 1. Methods: `filter` then `foldl`, each a recursive method on the list.
-fun sumEvensMethods(xs: Link[Int]) -> Int =
+fun sumEvensMethods(xs: Chain[Int]) -> Int =
   xs.filter(|x| x % 2 == 0).foldl(0, |a, x| a + x)
 # 2. A `for` over the list's `items()` form, with an `if` clause as the filter.
-fun sumEvensFor(xs: Link[Int]) -> Int =
+fun sumEvensFor(xs: Chain[Int]) -> Int =
   total := 0
   for x := range xs.items(), if x % 2 == 0
     total = total + x
   total
 # 3. A `while` loop with a local cursor, taking the list apart with a pattern.
-fun sumEvensWhile(xs: Link[Int]) -> Int =
+fun sumEvensWhile(xs: Chain[Int]) -> Int =
   total := 0
   cur := xs
   while true
-    if Cons(h, t) := cur
+    if Link(h, t) := cur
       if h % 2 == 0
         total = total + h
       cur = t
@@ -393,22 +394,22 @@ fun sumEvensWhile(xs: Link[Int]) -> Int =
 # A `for` is an expression when its source has a result: this form rebuilds a
 # list from the body's values, like `map`. It is generic: `T` is bound per call.
-# A bare `Nil` has no element type of its own, so `len(Nil)` is an error ("cannot
+# A bare `Empty` has no element type of its own, so `len(Empty)` is an error ("cannot
-# infer T"); annotate it, as `out` is here, or `empty: Link[Int] := Nil`.
+# infer T"); annotate it, as `out` is here, or `empty: Chain[Int] := Empty`.
-fun* collect(xs: Link[T]) *T -> Link[T] =
+fun* collect(xs: Chain[T]) *T -> Chain[T] =
-  out: Link[T] := Nil
+  out: Chain[T] := Empty
   for x := range xs.items()
     v := yield x
     out = cons(v, out)
   out.reverse()
 # Tail recursive: the recursive call is the last thing done, so it is a jump.
-fun countUp(xs: Link[Int], n: Int) -> Int = match xs
+fun countUp(xs: Chain[Int], n: Int) -> Int = match xs
-  Nil => n
+  Empty => n
-  Cons(_, t) => countUp(t, n + 1)
+  Link(_, t) => countUp(t, n + 1)
 # Builds `[n-1 .. 0]` with an accumulator, again as a tail call.
-fun build(n: Int, acc: Link[Int]) -> Link[Int] =
+fun build(n: Int, acc: Chain[Int]) -> Chain[Int] =
   if n <= 0 then acc else build(n - 1, cons(n - 1, acc))
 # ---------------------------------------------------------------------------
@@ -419,7 +420,7 @@ test "link basics"
   xs := fromTo(1, 6)
   assert xs.length() == 5
   assert joinInts(xs, ",") == "1,2,3,4,5"
-  empty: Link[Int] := Nil
+  empty: Chain[Int] := Empty
   assert empty.isEmpty()
   assert !xs.isEmpty()
   assert sum(xs) == 15
@@ -472,12 +473,12 @@ test "functions returning functions"
 test "deep list tail calls"
   # 200000 elements: counting needs tail calls, or the stack overflows.
-  big := build(200000, Nil)
+  big := build(200000, Empty)
   assert countUp(big, 0) == 200000
   assert sum(big) == 19999900000
 test "persistent tree"
-  t := fromLink(cons(5, cons(3, cons(8, cons(1, cons(4, cons(9, Nil)))))))
+  t := fromLink(cons(5, cons(3, cons(8, cons(1, cons(4, cons(9, Empty)))))))
   assert t.size() == 6
   assert t.depth() == 3
   assert t.member(4)
@@ -500,7 +501,7 @@ test "pattern matching"
   assert !Circle(r: 1.0).wide()
   assert firstTwo(fromTo(1, 5)) == "1,2"
   assert firstTwo(single(7)) == "7"
-  assert firstTwo(Nil) == "empty"
+  assert firstTwo(Empty) == "empty"
 test "scene count and draw"
   scene := demoScene()
@@ -531,7 +532,7 @@ test "scene click routes an event"
   scene := demoScene()
   r := click(scene, 115.0, 165.0)
   assert r.events.length() == 1
-  if Cons(e, _) := r.events
+  if Link(e, _) := r.events
     assert e.id == 5
     assert e.kind == Clicked
   kinds := r.node.draw(identityXf()).foldr("", |c, acc| c.kind + " " + acc)
@@ -546,13 +547,13 @@ test "loops three ways"
   assert sumEvensMethods(xs) == 30
   assert sumEvensFor(xs) == 30
   assert sumEvensWhile(xs) == 30
-  empty: Link[Int] := Nil
+  empty: Chain[Int] := Empty
   assert sumEvensFor(empty) == 0
   assert sumEvensWhile(empty) == 0
 test "loops build lists too"
   xs := fromTo(1, 5)
-  seen := List()
+  seen := Slice()
   xs.each(|x| seen.push(x * 2))
   assert seen.length() == 4
   doubled := for x := range collect(xs), if x > 1

plum-examples/game.plum CHANGED Viewed

@@ -10,7 +10,7 @@ module game
 import std/Str
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 import std/Math
 import std/Random
 import std/game/Vec2
@@ -37,8 +37,8 @@ record Body(x: Float, y: Float, vx: Float, vy: Float, angle: Float)
 record World(
   ship: Body,
-  orbs: List[Body],
+  orbs: Slice[Body],
-  mines: List[Body],
+  mines: Slice[Body],
   rng: Random,
   score: Int,
   best: Int,
@@ -56,7 +56,7 @@ record World(
     rng := Random(seed: seed)
     ship := Body(x: Rules.ArenaW / 2.0, y: Rules.ArenaH / 2.0, vx: 0.0, vy: 0.0, angle: 0.0)
     w := World(
-      ship: ship, orbs: List[Body](), mines: List[Body](), rng: rng, score: 0, best: 0,
+      ship: ship, orbs: Slice[Body](), mines: Slice[Body](), rng: rng, score: 0, best: 0,
       lives: Rules.StartLives, hurt: 0.0, clock: 0.0, over: false, sheet: sheet,
       pickupSound: -1, hitSound: -1, overSound: -1, musicSound: -1)
     for i := range Rules.OrbCount

plum-examples/game_loop.plum CHANGED Viewed

@@ -1,4 +1,4 @@
-# A tiny game update loop. Particles are structs in a `List`, which stores them
+# A tiny game update loop. Particles are structs in a `Slice`, which stores them
 # field by field (struct-of-arrays), so 100 frames of updates allocate nothing per
 # particle; dead ones are removed by swap-remove. Entities live in a `Map[Int,
 # Entity]` and are changed by events handled with `match`.
@@ -6,7 +6,7 @@ module game_loop
 import std/Str
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 import std/Map
 struct Vec2(x: Float, y: Float) =
@@ -33,7 +33,7 @@ record Stats(spawned: Int, removed: Int)
 # Move every particle one step; remove the dead by swap-remove (the last
 # particle takes the freed slot, so the list never shifts). Returns how many died.
-fun step(ps: List[Particle], dt: Float) -> Int =
+fun step(ps: Slice[Particle], dt: Float) -> Int =
   removed := 0
   i := 0
   while i < ps.length()
@@ -50,7 +50,7 @@ fun step(ps: List[Particle], dt: Float) -> Int =
       i = i + 1
   removed
-fun run(frames: Int, ps: List[Particle]) -> Stats =
+fun run(frames: Int, ps: Slice[Particle]) -> Stats =
   spawned := 0
   removed := 0
   for frame := range frames
@@ -71,14 +71,14 @@ fun handle(world: Map[Int, Entity], e: Event) =
       world.remove(id)
 test "100 frames: particles spawn, move and are swap-removed when dead"
-  ps := List[Particle]()
+  ps := Slice[Particle]()
   stats := run(100, ps)
   assert stats.spawned == 10
   assert stats.removed == 8
   assert ps.length() == 2
 test "survivors have moved and aged the expected amount"
-  ps := List[Particle]()
+  ps := Slice[Particle]()
   _ := run(100, ps)
   x := 0.0
   life := 0

plum-examples/game_pure_scene.plum CHANGED Viewed

@@ -17,7 +17,7 @@ module game_pure_scene
 import std/Str
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 import std/Math
 import std/Random
 import std/game/Vec2
@@ -158,7 +158,7 @@ own record Panel(
     Panel(
       id: id, x: x, y: y, width: w, height: h, originX: 0.0, originY: 0.0,
       scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: c, visible: true,
-      touchable: Disabled, actions: List[Action]())
+      touchable: Disabled, actions: Slice[Action]())
   override fun draw(self, m: Affine, tint: Color) =
@@ -174,7 +174,7 @@ own record Ship(
     Ship(
       id: Id.Ship, x: s.x - Rules.Half, y: s.y - Rules.Half, width: Rules.Size, height: Rules.Size,
       originX: Rules.Half, originY: Rules.Half, scaleX: 1.0, scaleY: 1.0, rotation: 0.0,
-      color: Color.White, visible: true, touchable: Disabled, actions: List[Action](),
+      color: Color.White, visible: true, touchable: Disabled, actions: Slice[Action](),
       clock: 0.0, tex: sheet)
@@ -197,7 +197,7 @@ own record Orb(
     Orb(
       id: id, x: at.x - Rules.Half, y: at.y - Rules.Half, width: Rules.Size, height: Rules.Size,
       originX: Rules.Half, originY: Rules.Half, scaleX: 1.0, scaleY: 1.0, rotation: 0.0,
-      color: Color.White, visible: true, touchable: Disabled, actions: List[Action](),
+      color: Color.White, visible: true, touchable: Disabled, actions: Slice[Action](),
       vx: at.vx, vy: at.vy, phase: phase, clock: 0.0, tex: sheet)
@@ -232,7 +232,7 @@ own record Mine(
     Mine(
       id: id, x: at.x - Rules.Half, y: at.y - Rules.Half, width: Rules.Size, height: Rules.Size,
       originX: Rules.Half, originY: Rules.Half, scaleX: 1.0, scaleY: 1.0, rotation: 0.0,
-      color: Color.White, visible: true, touchable: Disabled, actions: List[Action](),
+      color: Color.White, visible: true, touchable: Disabled, actions: Slice[Action](),
       vx: at.vx, vy: at.vy, spin: spin, clock: 0.0, tex: sheet)
@@ -263,7 +263,7 @@ own record Star(
     Star(
       id: Id.Star + i, x: Float({i * 7919} % 800) - r, y: Float({i * 104729} % 600) - r,
       width: r * 2.0, height: r * 2.0, originX: 0.0, originY: 0.0, scaleX: 1.0, scaleY: 1.0,
-      rotation: 0.0, color: Color.White, visible: true, touchable: Disabled, actions: List[Action](),
+      rotation: 0.0, color: Color.White, visible: true, touchable: Disabled, actions: Slice[Action](),
       seed: Float(i), clock: 0.0)
@@ -280,7 +280,7 @@ own record Star(
 # --- reading and changing the tree ---
 # The child of `a` reached by `path` (not empty), borrowed from the tree.
-fun nodeAt(a: Actor, path: List[Int], depth: Int) -> Actor =
+fun nodeAt(a: Actor, path: Slice[Int], depth: Int) -> Actor =
   ks := kidsOf(a)
   i := path.at(depth)
   if depth + 1 >= path.length()
@@ -292,7 +292,7 @@ fun find(root: Actor, id: Int) -> Actor =
   path := SceneTree.findPath(root, id) ?: crash "no such actor"
   nodeAt(root, path, 0)
-fun kidsOf(a: Actor) -> List[Actor] =
+fun kidsOf(a: Actor) -> Slice[Actor] =
   a.kids() ?: crash "not a group"
 fun setVisible(own a: Actor, v: Bool) -> Actor =
@@ -335,16 +335,16 @@ fun icon(sheet: Int, i: Int) -> Actor =
 # game-over overlay with its restart button.
 fun buildRoot(rng: Random, sheet: Int, best: Int) -> Actor =
   ship := newShip()
-  stars := List[Actor]()
+  stars := Slice[Actor]()
   for i := range 40
     stars.push(Star.create(i))
-  mines := List[Actor]()
+  mines := Slice[Actor]()
-  orbs := List[Actor]()
+  orbs := Slice[Actor]()
   for i := range Rules.OrbCount
     orbs.push(Orb.create(sheet, Float(i) * 0.1, Id.Orb + i, spawn(rng, ship.x, ship.y, 120.0, 40.0)))
   for i := range mineCount(0)
     mines.push(Mine.create(sheet, Id.Mine + i, spawn(rng, ship.x, ship.y, 220.0, 90.0), 2.0))
-  over := List[Actor]()
+  over := Slice[Actor]()
   over.push(Panel.create(Id.OverlayPanel, 0.0, 230.0, Rules.ArenaW, 170.0, Color(r: 0.0, g: 0.0, b: 0.0, a: 0.6)))
   over.push(hudLabel(Id.OverTitle, "Game over", 300.0, 244.0, 48.0, Color.Red))
   over.push(hudLabel(Id.OverHint, "Press Enter to play again", 270.0, 300.0, 24.0, Color.White))
@@ -354,13 +354,13 @@ fun buildRoot(rng: Random, sheet: Int, best: Int) -> Actor =
   over.push(btn)
   overlay := PureScene.group(Id.Overlay, 0.0, 0.0, 0.0, 0.0, over)
   overlay.visible = false
-  hud := List[Actor]()
+  hud := Slice[Actor]()
   hud.push(hudLabel(Id.Score, "Score 0", 16.0, 12.0, 28.0, Color.White))
   hud.push(hudLabel(Id.Best, "Best {best}", 16.0, 44.0, 20.0, Color.Yellow))
   for i := range Rules.StartLives
     hud.push(icon(sheet, i))
   hud.push(overlay)
-  layers := List[Actor]()
+  layers := Slice[Actor]()
   layers.push(Panel.create(Id.Backdrop, 0.0, 0.0, Rules.ArenaW, Rules.ArenaH, Color.rgb(0.07, 0.08, 0.16)))
   layers.push(PureScene.group(Id.StarLayer, 0.0, 0.0, 0.0, 0.0, stars))
   layers.push(PureScene.group(Id.MineLayer, 0.0, 0.0, 0.0, 0.0, mines))
@@ -472,7 +472,7 @@ fun overlaps(ax: Float, ay: Float, ra: Float, bx: Float, by: Float, rb: Float) -
   Math.hypot(ax - bx, ay - by) < ra + rb
 # The stage after `inputs` and `dt`, appending the events it raised to `events`.
-fun frameInto(own s: Stage, dt: Float, inputs: List[Input], events: List[UiEvent]) -> Stage =
+fun frameInto(own s: Stage, dt: Float, inputs: Slice[Input], events: Slice[UiEvent]) -> Stage =
   h := s.frame(dt, inputs)
   for i := range h.events.length()
     events.push(h.events.at(i))
@@ -481,9 +481,9 @@ fun frameInto(own s: Stage, dt: Float, inputs: List[Input], events: List[UiEvent
 # One frame: the stage takes the pointer `inputs` and advances every actor by `dt`
 # (a click on the restart button restarts), then the rules look at the result. Once
 # the game is over the actors only animate. Returns true when it restarted.
-fun advance(w: World, ax: Float, ay: Float, dt: Float, inputs: List[Input]) -> Bool =
+fun advance(w: World, ax: Float, ay: Float, dt: Float, inputs: Slice[Input]) -> Bool =
   w.clock = w.clock + dt
-  events := List[UiEvent]()
+  events := Slice[UiEvent]()
   w.stage = frameInto(w.stage, dt, inputs, events)
   for i := range events.length()
     e := events.at(i)
@@ -532,7 +532,7 @@ fun advance(w: World, ax: Float, ay: Float, dt: Float, inputs: List[Input]) -> B
 # One simulation step without pointer input.
 fun step(w: World, ax: Float, ay: Float, dt: Float) -> Bool =
-  advance(w, ax, ay, dt, List[Input]())
+  advance(w, ax, ay, dt, Slice[Input]())
 # The camera that fits the arena into a screen of `sw` by `sh` pixels, centred.
 fun fitCamera(sw: Float, sh: Float) -> Affine =
@@ -826,7 +826,7 @@ test "restart_button_click_restarts"
   assert find(w.stage.root, Id.Restart).visible
   down := Input(kind: PointerDown, x: 400.0, y: 364.0)
   up := Input(kind: PointerUp, x: 400.0, y: 364.0)
-  taps := List[Input]()
+  taps := Slice[Input]()
   taps.push(down)
   taps.push(up)
   restarted := advance(w, 0.0, 0.0, 0.016, taps)
@@ -839,7 +839,7 @@ test "restart_button_click_restarts"
 test "a click on the restart button while playing does nothing"
   w := emptyWorld()
   w.score = 30
-  taps := List[Input]()
+  taps := Slice[Input]()
   taps.push(Input(kind: PointerDown, x: 400.0, y: 364.0))
   taps.push(Input(kind: PointerUp, x: 400.0, y: 364.0))
   restarted := advance(w, 0.0, 0.0, 0.016, taps)

plum-examples/game_scene.plum CHANGED Viewed

@@ -24,7 +24,7 @@ module game_scene
 import std/Str
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 import std/Math
 import std/Random
 import std/game/Vec2
@@ -246,12 +246,12 @@ record World(
   ship: Ship,
   mines: Group,
   orbs: Group,
-  mineList: List[Mine],
+  mineList: Slice[Mine],
-  orbList: List[Orb],
+  orbList: Slice[Orb],
   overlay: Group,
   scoreText: Text,
   bestText: Text,
-  lifeIcons: List[Sprite],
+  lifeIcons: Slice[Sprite],
   rng: Random,
   score: Int,
   best: Int,
@@ -281,7 +281,7 @@ record World(
     bestText.y = 44.0
     hud.add(scoreText)
     hud.add(bestText)
-    icons := List[Sprite]()
+    icons := Slice[Sprite]()
     for i := range Rules.StartLives
       icon := Sprite.create(sheet, 0.0, 0.0, Rules.Cell, Rules.Cell, 32.0, 32.0)
       icon.x = Rules.ArenaW - 40.0 - Float(i) * 36.0
@@ -295,7 +295,7 @@ record World(
     overlay.add(Text.create("Press Enter to play again", 24.0, Color.White).at(270.0, 316.0))
     hud.add(overlay)
     w := World(
-      camScale: 1.0, ship: ship, mines: mines, orbs: orbs, mineList: List[Mine](), orbList: List[Orb](),
+      camScale: 1.0, ship: ship, mines: mines, orbs: orbs, mineList: Slice[Mine](), orbList: Slice[Orb](),
       overlay: overlay, scoreText: scoreText, bestText: bestText, lifeIcons: icons,
       rng: rng, score: 0, best: 0, lives: Rules.StartLives, over: false, clock: 0.0, sheet: sheet,
       pickupSound: -1, hitSound: -1, overSound: -1, musicSound: -1)

plum-examples/game_state_view.plum CHANGED Viewed

@@ -5,11 +5,11 @@
 # "Again" button restarts after the game is over.
 #
 # The game is three plain pieces. `State` is plain data: the ship, the orbs and the
-# mines (recursive `Link` lists keyed by id), the score, the random seed and the screen
+# mines (cons `List` lists keyed by id), the score, the random seed and the screen
 # size. `Msg` is what can happen to it (a tick of time, a resize, a restart), an enum
 # with inline variants. `step(state, msg)` is pure and returns the next `State`;
 # `view(state)` is pure too and builds a fresh `SceneNode` picture every frame, which
-# `Picture.draw` interprets. Both are structural recursion over `Link` and `Nodes`:
+# `Picture.draw` interprets. Both are structural recursion over `Link` and `List[SceneNode]`:
 # no loop runs in `step` or `view`. There is no
 # retained scene: the restart button is found by `Picture.hitPath` on the picture
 # the player is looking at. The `World` record is the host shell: it holds the
@@ -18,6 +18,7 @@ module game_state_view
 import std/Str
 import std/Int
 import std/Float
+import std/Slice
 import std/List
 import std/Math
 import std/game/Vec2
@@ -72,8 +73,8 @@ struct Mine(id: Int, x: Float, y: Float, vx: Float, vy: Float, rotation: Float,
 # the view needs: the sprite sheet and the render target of the game-over filter.
 record State(
   ship: ShipState,
-  orbs: Link[Orb],
+  orbs: List[Orb],
-  mines: Link[Mine],
+  mines: List[Mine],
   seed: Int,
   score: Int,
   best: Int,
@@ -92,36 +93,34 @@ enum Msg =
   | Resize(w: Float, h: Float)
   | Restart(seed: Int)
-# A recursive list: the empty `Nil`, or a head in front of another list.
-enum Link[T] = Nil | Cons(head: T, tail: Link[T])
-fun mapLink(xs: Link[A], f: fn(A) -> B) -> Link[B] = match xs
+fun mapLink(xs: List[A], f: fn(A) -> B) -> List[B] = match xs
   Nil => Nil
   Cons(h, t) => Cons(head: f(h), tail: mapLink(t, f))
-fun lenLink(xs: Link[T]) -> Int = match xs
+fun lenLink(xs: List[T]) -> Int = match xs
   Nil => 0
   Cons(_, t) => 1 + lenLink(t)
 # `xs` with `x` added at the end.
-fun snoc(xs: Link[T], x: T) -> Link[T] = match xs
+fun snoc(xs: List[T], x: T) -> List[T] = match xs
   Nil => Cons(head: x, tail: Nil)
   Cons(h, t) => Cons(head: h, tail: snoc(t, x))
 # `xs` with the element at `i` replaced by `x`.
-fun replaceNth(xs: Link[T], i: Int, x: T) -> Link[T] = match xs
+fun replaceNth(xs: List[T], i: Int, x: T) -> List[T] = match xs
   Nil => Nil
   Cons(h, t) => if i <= 0 then Cons(head: x, tail: t) else Cons(head: h, tail: replaceNth(t, i - 1, x))
 # The element at `i`, or `dflt` past the end.
-fun nthOr(xs: Link[T], i: Int, dflt: T) -> T = match xs
+fun nthOr(xs: List[T], i: Int, dflt: T) -> T = match xs
   Nil => dflt
   Cons(h, t) => if i <= 0 then h else nthOr(t, i - 1, dflt)
 # The nodes f(x) for every x of `xs`, followed by `rest`.
-fun toNodes(xs: Link[T], f: fn(T) -> SceneNode, rest: Nodes) -> Nodes = match xs
+fun toNodes(xs: List[T], f: fn(T) -> SceneNode, rest: List[SceneNode]) -> List[SceneNode] = match xs
   Nil => rest
-  Cons(h, t) => More(head: f(h), tail: toNodes(t, f, rest))
+  Cons(h, t) => Cons(head: f(h), tail: toNodes(t, f, rest))
 # --- small pure helpers ---
@@ -223,9 +222,9 @@ fun mineMove(k: Mine, dt: Float) -> Mine =
 # --- the state ---
 # A built list of orbs and the seed to continue from.
-record OrbsMade(orbs: Link[Orb], seed: Int)
+record OrbsMade(orbs: List[Orb], seed: Int)
-record MinesMade(mines: Link[Mine], seed: Int)
+record MinesMade(mines: List[Mine], seed: Int)
 # Orbs `i` and up to OrbCount, each at a random spot away from the ship.
 fun makeOrbs(i: Int, seed: Int, ship: ShipState) -> OrbsMade =
@@ -265,9 +264,9 @@ fun freeze(s: State) -> State =
   n
 # The orbs after the ship collected the ones it touches, with the score and seed.
-record Collected(orbs: Link[Orb], seed: Int, score: Int)
+record Collected(orbs: List[Orb], seed: Int, score: Int)
-fun collectOrbs(orbs: Link[Orb], ship: ShipState, seed: Int, score: Int) -> Collected = match orbs
+fun collectOrbs(orbs: List[Orb], ship: ShipState, seed: Int, score: Int) -> Collected = match orbs
   Nil => Collected(orbs: Nil, seed: seed, score: score)
   Cons(o, rest) =>
     if overlaps(ship.x, ship.y, Rules.ShipRadius, o.x, o.y, Rules.OrbRadius)
@@ -280,14 +279,14 @@ fun collectOrbs(orbs: Link[Orb], ship: ShipState, seed: Int, score: Int) -> Coll
       Collected(orbs: Cons(head: o, tail: kept.orbs), seed: kept.seed, score: kept.score)
 # `mines` grown (new mines go at the end) until there are `want`.
-fun growMines(mines: Link[Mine], have: Int, want: Int, seed: Int, ship: ShipState) -> MinesMade =
+fun growMines(mines: List[Mine], have: Int, want: Int, seed: Int, ship: ShipState) -> MinesMade =
   if have >= want
     return MinesMade(mines: mines, seed: seed)
   sp := spawn(seed, ship.x, ship.y, 220.0, 90.0)
   added := snoc(mines, mineAt(Id.Mine + have, 0.0, 2.0, 0.0, Motion(x: sp.x, y: sp.y, vx: sp.vx, vy: sp.vy)))
   growMines(added, have + 1, want, sp.seed, ship)
-fun touchesMine(mines: Link[Mine], ship: ShipState) -> Bool = match mines
+fun touchesMine(mines: List[Mine], ship: ShipState) -> Bool = match mines
   Nil => false
   Cons(k, rest) => overlaps(ship.x, ship.y, Rules.ShipRadius, k.x, k.y, Rules.MineRadius) || touchesMine(rest, ship)
@@ -354,8 +353,8 @@ fun starView(i: Int, clock: Float) -> SceneNode =
   CircleShape(cx: Float({i * 7919} % 800), cy: Float({i * 104729} % 600), r: r, color: Color(r: 0.7, g: 0.8, b: 1.0, a: twinkle))
 # The stars `i` and up to 40.
-fun starNodes(i: Int, clock: Float) -> Nodes =
+fun starNodes(i: Int, clock: Float) -> List[SceneNode] =
-  if i >= 40 then End else More(head: starView(i, clock), tail: starNodes(i + 1, clock))
+  if i >= 40 then Nil else Cons(head: starView(i, clock), tail: starNodes(i + 1, clock))
 fun starsView(clock: Float) -> SceneNode =
   Group(transform: Identity, children: starNodes(0, clock))
@@ -363,79 +362,79 @@ fun starsView(clock: Float) -> SceneNode =
 fun mineView(sheet: Int, k: Mine) -> SceneNode =
   Group(
     transform: Compose(first: Translate(dx: k.x, dy: k.y), then: Rotate(radians: k.rotation)),
-    children: More(head: cell(sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(k.clock, 4, 4.0), 2), tail: End))
+    children: Cons(head: cell(sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(k.clock, 4, 4.0), 2), tail: Nil))
 # The glow is drawn additively, then the sprite on top.
 fun orbView(sheet: Int, o: Orb) -> SceneNode =
   glow := Group(
     transform: Identity,
-    children: More(
+    children: Cons(
       head: CircleShape(cx: 0.0, cy: 0.0, r: 26.0, color: Color(r: 0.35, g: 0.22, b: 0.0, a: 0.5)),
-      tail: More(head: CircleShape(cx: 0.0, cy: 0.0, r: 17.0, color: Color(r: 0.6, g: 0.4, b: 0.05, a: 0.5)), tail: End)))
+      tail: Cons(head: CircleShape(cx: 0.0, cy: 0.0, r: 17.0, color: Color(r: 0.6, g: 0.4, b: 0.05, a: 0.5)), tail: Nil)))
   Group(
     transform: Translate(dx: o.x, dy: o.y),
-    children: More(
+    children: Cons(
       head: Filter(effect: BlendFx(mode: Blend.Add), child: glow, target: 0 - 1),
-      tail: More(head: cell(sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(o.clock + o.phase, 4, 8.0), 1), tail: End)))
+      tail: Cons(head: cell(sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(o.clock + o.phase, 4, 8.0), 1), tail: Nil)))
 # The ship blinks while hurt and is gone once the game is over (an empty group keeps the slots).
 fun shipView(s: State) -> SceneNode =
   blink := s.ship.hurt > 0.0 && frameOf(s.clock, 2, 10.0) == 0
   if s.over || blink
-    return Group(transform: Identity, children: End)
+    return Group(transform: Identity, children: Nil)
   Group(
     transform: Compose(first: Translate(dx: s.ship.x, dy: s.ship.y), then: Rotate(radians: s.ship.rotation)),
-    children: More(
+    children: Cons(
       head: CircleShape(cx: 0.0, cy: 0.0, r: 17.0, color: Color(r: 0.4, g: 0.8, b: 1.0, a: 0.12)),
-      tail: More(head: cell(s.sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(s.clock, 4, 14.0), 0), tail: End)))
+      tail: Cons(head: cell(s.sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(s.clock, 4, 14.0), 0), tail: Nil)))
 # One life icon per remaining life, from the right edge going left.
-fun lifeNodes(i: Int, lives: Int, sheet: Int) -> Nodes =
+fun lifeNodes(i: Int, lives: Int, sheet: Int) -> List[SceneNode] =
   if i >= lives
-    End
+    Nil
   else
-    More(head: cell(sheet, Rules.ArenaW - 40.0 - Float(i) * 36.0, 12.0, 32.0, 0, 0), tail: lifeNodes(i + 1, lives, sheet))
+    Cons(head: cell(sheet, Rules.ArenaW - 40.0 - Float(i) * 36.0, 12.0, 32.0, 0, 0), tail: lifeNodes(i + 1, lives, sheet))
 fun hudView(s: State) -> SceneNode =
   Group(
     transform: Identity,
-    children: More(
+    children: Cons(
       head: Text(text: "Score {s.score}", x: 16.0, y: 12.0, size: 28.0, color: Color.White),
-      tail: More(head: Text(text: "Best {s.best.max(s.score)}", x: 16.0, y: 44.0, size: 20.0, color: Color.Yellow), tail: lifeNodes(0, s.lives, s.sheet))))
+      tail: Cons(head: Text(text: "Best {s.best.max(s.score)}", x: 16.0, y: 44.0, size: 20.0, color: Color.Yellow), tail: lifeNodes(0, s.lives, s.sheet))))
 # The game-over panel with the restart button, faded in through a render-target filter.
 # While playing it is an empty group, so nothing in it can be hit.
 fun overlayView(s: State) -> SceneNode =
   if !s.over
-    return Group(transform: Identity, children: End)
+    return Group(transform: Identity, children: Nil)
   button := Group(
     transform: Identity,
-    children: More(
+    children: Cons(
       head: RectShape(x: 340.0, y: 342.0, w: 120.0, h: 44.0, color: Color(r: 0.5, g: 0.8, b: 1.0, a: 0.9)),
-      tail: More(head: Text(text: "Again", x: 372.0, y: 352.0, size: 24.0, color: Color.White), tail: End)))
+      tail: Cons(head: Text(text: "Again", x: 372.0, y: 352.0, size: 24.0, color: Color.White), tail: Nil)))
   panel := Group(
     transform: Identity,
-    children: More(
+    children: Cons(
       head: RectShape(x: 0.0, y: 230.0, w: Rules.ArenaW, h: 170.0, color: Color(r: 0.0, g: 0.0, b: 0.0, a: 0.6)),
-      tail: More(
+      tail: Cons(
         head: Text(text: "Game over", x: 300.0, y: 244.0, size: 48.0, color: Color.Red),
-        tail: More(
+        tail: Cons(
           head: Text(text: "Press Enter to play again", x: 270.0, y: 300.0, size: 24.0, color: Color.White),
-          tail: More(head: button, tail: End)))))
+          tail: Cons(head: button, tail: Nil)))))
   Filter(effect: Alpha(alpha: {s.overClock * 2.0}.min(1.0)), child: panel, target: s.target)
 # The whole picture, in drawing order, under the camera that fits the arena on screen.
 fun view(s: State) -> SceneNode =
   z := zoomOf(s)
-  layers := More(
+  layers := Cons(
     head: RectShape(x: 0.0, y: 0.0, w: Rules.ArenaW, h: Rules.ArenaH, color: Color.rgb(0.07, 0.08, 0.16)),
-    tail: More(
+    tail: Cons(
       head: starsView(s.clock),
-      tail: More(
+      tail: Cons(
-        head: Group(transform: Identity, children: toNodes(s.mines, |k| mineView(s.sheet, k), End)),
+        head: Group(transform: Identity, children: toNodes(s.mines, |k| mineView(s.sheet, k), Nil)),
-        tail: More(
+        tail: Cons(
-          head: Group(transform: Identity, children: toNodes(s.orbs, |o| orbView(s.sheet, o), End)),
+          head: Group(transform: Identity, children: toNodes(s.orbs, |o| orbView(s.sheet, o), Nil)),
-          tail: More(head: shipView(s), tail: More(head: hudView(s), tail: More(head: overlayView(s), tail: End)))))))
+          tail: Cons(head: shipView(s), tail: Cons(head: hudView(s), tail: Cons(head: overlayView(s), tail: Nil)))))))
   Group(transform: Compose(first: Translate(dx: offsetX(s), dy: offsetY(s)), then: Scale(sx: z, sy: z)), children: layers)
 # True when (x, y) in screen pixels is on the restart button of the picture `view` builds.
@@ -552,9 +551,9 @@ fun countNodes(n: SceneNode) -> Int = match n
   Filter(_, child, _) => 1 + countNodes(child)
   _ => 1
-fun countKids(ks: Nodes) -> Int = match ks
+fun countKids(ks: List[SceneNode]) -> Int = match ks
-  End => 0
+  Nil => 0
-  More(h, t) => countNodes(h) + countKids(t)
+  Cons(h, t) => countNodes(h) + countKids(t)
 test "steering accelerates and drag slows the ship"
   s := shipStep(newShip(), 1.0, 0.0, 0.1)

plum-examples/generics.plum CHANGED Viewed

@@ -4,12 +4,12 @@ module generics
 import std/Str
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 import std/Map
 # Generics are erased: a `T` is a nullable object reference at run time, and
 # Int / Float values are boxed when they cross a generic edge (a `T` param,
-# a List slot, a Map value, an error-union payload) and unboxed on the way out. These
+# a Slice slot, a Map value, an error-union payload) and unboxed on the way out. These
 # tests push awkward values through every such edge and check they come back
 # bit-for-bit.
@@ -39,7 +39,7 @@ fun pick(x: T, f: fn(T) -> T) -> T =
 fun twice(f: fn(T) -> T, x: T) -> T =
   f(f(x))
-fun readDeep(outer: List[List[Map[Str, Int]]], r: Int, c: Int, key: Str) -> error{OutOfBounds, KeyNotFound}!Int =
+fun readDeep(outer: Slice[Slice[Map[Str, Int]]], r: Int, c: Int, key: Str) -> error{OutOfBounds, KeyNotFound}!Int =
   row := try outer.get(r)
   m := try row.get(c)
   v := try m.get(key)
@@ -72,7 +72,7 @@ fun nameOf(s: T) -> Str =
 # the closure stored in the `add` field (a method named `add` would win).
 record Num[T](add: fn(T, T) -> T, zero: T)
-fun sumWith(xs: List[T], num: Num[T]) -> T =
+fun sumWith(xs: Slice[T], num: Num[T]) -> T =
   acc := num.zero
   for x := range xs
     acc = num.add(acc, x)
@@ -114,7 +114,7 @@ record Crate[T](value: T) =
   fun viaLocal(self) -> T =
     c: Crate := self
-    kept := List[Crate]()
+    kept := Slice[Crate]()
     kept.push(c)
     kept.at(0).value
@@ -162,14 +162,14 @@ test "Float specials survive a generic fn"
   assert id(1.5) == 1.5
 test "Int and Float extremes survive List push/get"
-  ints := List[Int]()
+  ints := Slice[Int]()
   ints.push(9223372036854775807)
   ints.push(0 - 9223372036854775807 - 1)
   ints.push(9007199254740993)
   assert {ints.get(0) catch 0} == 9223372036854775807
   assert {ints.get(1) catch 0} == 0 - 9223372036854775807 - 1
   assert {ints.get(2) catch 0} == 9007199254740993
-  floats := List[Float]()
+  floats := Slice[Float]()
   floats.push(0.0 / 0.0)
   floats.push(-0.0)
   floats.push(5e-324)
@@ -213,12 +213,12 @@ test "Float specials survive an error-union payload with ? and catch"
 test "List[List[Map[Str, Int]]] builds and reads back"
   m1 := Map("ok" => 7)
   m2 := Map("big" => 9223372036854775807)
-  inner1 := List[Map[Str, Int]]()
+  inner1 := Slice[Map[Str, Int]]()
   inner1.push(m1)
   inner1.push(m2)
-  inner2 := List[Map[Str, Int]]()
+  inner2 := Slice[Map[Str, Int]]()
   inner2.push(m2)
-  outer := List[List[Map[Str, Int]]]()
+  outer := Slice[Slice[Map[Str, Int]]]()
   outer.push(inner1)
   outer.push(inner2)
   assert outer.length() == 2
@@ -230,12 +230,12 @@ test "List[List[Map[Str, Int]]] builds and reads back"
   assert {readDeep(outer, 2, 0, "big") catch 97} == 97
 test "a generic receiver's methods are chosen per element type"
-  ints := List(1, 22, 333)
+  ints := Slice(1, 22, 333)
-  strs := List[Str]()
+  strs := Slice[Str]()
   for n := range ints
     strs.push("n{n}")
   assert strs.join(",") == "n1,n22,n333"
-  lens := List[Int]()
+  lens := Slice[Int]()
   for s := range strs
     lens.push(s.length())
   assert lens.join(",") == "2,3,4"
@@ -256,10 +256,10 @@ test "closures nested three deep capture Int and Str locals through generic para
 test "a duck-typed generic fn dispatches statically per instantiation"
   assert nameOf(Circle(r: 1.0)) == "circle"
   assert nameOf(Square(s: 1.0)) == "square"
-  shapes := List[Circle]()
+  shapes := Slice[Circle]()
   shapes.push(Circle(r: 2.0))
   shapes.push(Circle(r: 3.0))
-  names := List[Str]()
+  names := Slice[Str]()
   total := 0.0
   for s := range shapes
     names.push(s.name())
@@ -289,22 +289,22 @@ test "num_record_passed_explicitly"
   intNum := Num(add: |a, b| a + b, zero: 0)
   floatNum := Num(add: |a, b| a + b, zero: 0.0)
   strNum := Num(add: |a, b| a + b, zero: "")
-  assert sumWith(List(1, 2, 3), intNum) == 6
+  assert sumWith(Slice(1, 2, 3), intNum) == 6
-  assert sumWith(List(1.5, 2.5), floatNum) == 4.0
+  assert sumWith(Slice(1.5, 2.5), floatNum) == 4.0
-  assert sumWith(List("a", "b"), strNum) == "ab"
+  assert sumWith(Slice("a", "b"), strNum) == "ab"
 test "untyped_empty_list_field_access_after_push"
-  out := List()
+  out := Slice()
   out.push(Circle(r: 3.0))
   assert out.at(0).r == 3.0
   first := out.at(0)
   assert first.r == 3.0
 test "nested generic constructor call as an argument"
-  r := List(List(1, 2), List(3))
+  r := Slice(Slice(1, 2), Slice(3))
   assert r.length() == 2
   assert r.at(0).length() == 2
-  s := List(List("a"))
+  s := Slice(Slice("a"))
   assert s.at(0).at(0) == "a"
 test "a generic record is specialized per type and its methods run"

plum-examples/json.plum CHANGED Viewed

@@ -3,10 +3,10 @@
 # `T` of `decode` comes from the annotation. Records write both by hand.
 import std/Int
 import std/Str
-import std/List
+import std/Slice
 import std/Json
-record House(name: Str, rooms: Int, tags: List[Str], annex: List[House]) =
+record House(name: Str, rooms: Int, tags: Slice[Str], annex: Slice[House]) =
   fun toJson(self) -> Json =
     Json.object("name" => self.name.toJson(), "rooms" => self.rooms.toJson(), "tags" => self.tags.toJson(), "annex" => self.annex.toJson())
@@ -17,9 +17,9 @@ record House(name: Str, rooms: Int, tags: List[Str], annex: List[House]) =
     annex := try annexOf(try j.field("annex"))
     return House(name: name, rooms: rooms, tags: tags, annex: annex)
-fun tagsOf(j: Json) -> JsonError!List[Str] = j.into()
+fun tagsOf(j: Json) -> JsonError!Slice[Str] = j.into()
-fun annexOf(j: Json) -> JsonError!List[House] = j.into()
+fun annexOf(j: Json) -> JsonError!Slice[House] = j.into()
 fun parseHouse(s: Str) -> JsonError!House = Json.decode(s)
@@ -32,10 +32,10 @@ fun house(a: Pair[Str, Json], b: Pair[Str, Json]) -> Str =
   Json.object(a, b, "tags" => Json.array(), "annex" => Json.array()).toStr()
 test "nested round trip"
-  tags := List[Str]()
+  tags := Slice[Str]()
   tags.push("old")
-  annex := List[House]()
+  annex := Slice[House]()
-  annex.push(House(name: "shed", rooms: 1, tags: List[Str](), annex: List[House]()))
+  annex.push(House(name: "shed", rooms: 1, tags: Slice[Str](), annex: Slice[House]()))
   h := House(name: "main", rooms: 5, tags: tags, annex: annex)
   text := Json.encode(h)
   back: JsonError!House := Json.decode(text)

plum-examples/loops.plum CHANGED Viewed

@@ -3,25 +3,25 @@
 import std/Str
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 import std/Array
 import std/Testing
 import std/Seq
-fun sumList(xs: List[Int]) -> Int =
+fun sumList(xs: Slice[Int]) -> Int =
   total := 0
   for x := range xs
     total = total + x
   return total
-fun firstOver(xs: List[Int], limit: Int) -> Int =
+fun firstOver(xs: Slice[Int], limit: Int) -> Int =
   for x := range xs
     if x > limit
       return x
   return -1
 test "plain_iterable_for: List and Array"
-  xs := List(1, 2, 3, 4)
+  xs := Slice(1, 2, 3, 4)
   assert sumList(xs) == 10
   arr := Array.filled(3, 7)
   total := 0
@@ -30,28 +30,28 @@ test "plain_iterable_for: List and Array"
   assert total == 21
 test "index_value_binders: i, x"
-  xs := List(10, 20, 30)
+  xs := Slice(10, 20, 30)
   acc := 0
   for i, x := range xs
     acc = acc + i * x
   assert acc == 80
 test "clause_if_keeps_when_true: if cond keeps the element, false skips it"
-  xs := List(1, 2, 3, 4, 5, 6)
+  xs := Slice(1, 2, 3, 4, 5, 6)
   total := 0
   for x := range xs, if x % 2 == 0
     total = total + x
   assert total == 12
 test "clause_bind_scoped: name := expr is visible to later clauses and body"
-  xs := List(1, 2, 3, 4)
+  xs := Slice(1, 2, 3, 4)
   total := 0
   for x := range xs, sq := x * x, if sq > 9
     total = total + sq
   assert total == 16
 test "break_continue_return_semantics"
-  xs := List(1, 2, 3, 4, 5)
+  xs := Slice(1, 2, 3, 4, 5)
   total := 0
   for x := range xs
     if x == 2
@@ -64,8 +64,8 @@ test "break_continue_return_semantics"
   assert firstOver(xs, 9) == -1
 test "nested iterable loops"
-  xs := List(1, 2)
+  xs := Slice(1, 2)
-  ys := List(10, 20)
+  ys := Slice(10, 20)
   total := 0
   for x := range xs
     for y := range ys

plum-examples/optionals.plum CHANGED Viewed

@@ -1,6 +1,6 @@
 import std/Int
 import std/Str
-import std/List
+import std/Slice
 import std/Float
 # Optionals: `T?` is a `T` or `null`. A plain `T` in a `T?` slot is the present
 # value. An optional is handled with `?:` (Kotlin elvis), `if x := opt`,
@@ -51,13 +51,13 @@ fun viaTry(n: Int) -> error{Bad}!Int =
   v := try fallible(n)
   v ?: -1
-fun nextItem(items: List[Int], i: Int) -> Int? =
+fun nextItem(items: Slice[Int], i: Int) -> Int? =
   if i < items.length()
     return items.get(i)!
   null
-fun sparse() -> List[Int?] =
+fun sparse() -> Slice[Int?] =
-  List(1, null, 3)
+  Slice(1, null, 3)
 fun sumBig() -> Int =
   Int.Max + Int.Min
@@ -149,7 +149,7 @@ test "if_bind_optional"
     assert b.label == "in"
 test "while_bind_optional"
-  items := List(3, 2, 1)
+  items := Slice(3, 2, 1)
   total := 0
   i := 0
   while v := nextItem(items, i)

plum-examples/own_list.plum CHANGED Viewed

@@ -1,11 +1,11 @@
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 own record Cell(x: Float)
 test "map_in_place_updates_all"
-  xs := List(Cell(x: 1.0), Cell(x: 2.0), Cell(x: 3.0))
+  xs := Slice(Cell(x: 1.0), Cell(x: 2.0), Cell(x: 3.0))
   ys := xs.mapInPlace(|c| Cell(..c, x: c.x + 1.0))
   assert ys.length() == 3
   assert {ys.at(0).x - 2.0}.abs() < 1e-6
@@ -13,7 +13,7 @@ test "map_in_place_updates_all"
   assert {ys.at(2).x - 4.0}.abs() < 1e-6
 test "take_then_put_round_trip"
-  xs := List(Cell(x: 1.0), Cell(x: 2.0))
+  xs := Slice(Cell(x: 1.0), Cell(x: 2.0))
   c := xs.takeAt(1)
   d := Cell(..c, x: c.x + 10.0)
   xs.putAt(1, d)
@@ -22,12 +22,12 @@ test "take_then_put_round_trip"
   assert {xs.at(0).x - 1.0}.abs() < 1e-6
 test "at_borrows"
-  xs := List(Cell(x: 5.0))
+  xs := Slice(Cell(x: 5.0))
   assert {xs.at(0).x - 5.0}.abs() < 1e-6
   assert {xs.at(0).x - 5.0}.abs() < 1e-6
 test "put_after_take_keeps_length"
-  xs := List(Cell(x: 1.0), Cell(x: 2.0), Cell(x: 3.0))
+  xs := Slice(Cell(x: 1.0), Cell(x: 2.0), Cell(x: 3.0))
   c := xs.takeAt(0)
   xs.putAt(0, c)
   assert xs.length() == 3

plum-examples/scene.plum CHANGED Viewed

@@ -15,7 +15,7 @@ module scene
 import std/Str
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 import std/Math
 import std/game/Vec2
 import std/game/Color
@@ -91,9 +91,9 @@ record Walker(Actor, pace: Float, phase: Float, tex: Int, srcX: Float) =
 # planet and moon, each planet followed by its moons), as are `halos` (the glow shown when selected).
 record Sky(
   stage: Stage,
-  bodies: List[Actor],
+  bodies: Slice[Actor],
-  halos: List[Actor],
+  halos: Slice[Actor],
-  names: List[Str],
+  names: Slice[Str],
   sun: Spinner,
   label: Text,
   crowd: Group,
@@ -131,14 +131,14 @@ fun newSky(sheet: Int) -> Sky =
   label.x = 16.0
   label.y = 12.0
   sky := Sky(
-    stage: stage, bodies: List[Actor](), halos: List[Actor](), names: List[Str](),
+    stage: stage, bodies: Slice[Actor](), halos: Slice[Actor](), names: Slice[Str](),
     sun: sun, label: label, crowd: Group(), front: null, selected: -1, clock: 0.0, paused: false, map: -1)
   # faint orbit rings, added first so every body draws (and is hit) above them
   for i := range Layout.Planets
     r := 90.0 + Float(i) * 60.0
     stage.root.add(Circle.create(r, Color(r: 1.0, g: 1.0, b: 1.0, a: 0.04)).at(Layout.CenterX - r, Layout.CenterY - r))
-  planetNames := List("Ember", "Cinder", "Ashen", "Glacier")
+  planetNames := Slice("Ember", "Cinder", "Ashen", "Glacier")
-  moons := List(0, 1, 2, 1)
+  moons := Slice(0, 1, 2, 1)
   for i := range Layout.Planets
     orbit := Orbit(speed: 0.9 / Float(1 + i)).at(Layout.CenterX, Layout.CenterY)
     planet := addBody(sky, sheet, planetNames.at(i), 2, i, 40.0, 1.5).at(90.0 + Float(i) * 60.0, 0.0)

plum-examples/seq.plum CHANGED Viewed

@@ -2,7 +2,7 @@
 # `skip`, `map`, `filter`, `find`, `fold`) to process collections in `for` loops.
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 import std/Seq
 import std/Map
 import std/Str
@@ -11,7 +11,7 @@ import std/Str
 # `for` source. Adapters (take, skip, stepBy, zip, reversed, chunks) reshape the
 # sequence and may appear anywhere in a chain; terminals (filter, map, find, fold,
 # count, any, all, each, firstN, toList) take the `for` body and end the chain.
-# A whole chain is ONE loop: no closure, no intermediate List.
+# A whole chain is ONE loop: no closure, no intermediate Slice.
 # Closure-free chains. A method chain such as
 #
@@ -37,8 +37,8 @@ fun dist2(ax: Float, ay: Float, bx: Float, by: Float) -> Float =
   dy := ay - by
   dx * dx + dy * dy
-fun army() -> List[Soldier] =
+fun army() -> Slice[Soldier] =
-  List(
+  Slice(
     Soldier(name: "a", team: 1, hp: 10.0, x: 0.0, y: 0.0),
     Soldier(name: "b", team: 2, hp: 0.0, x: 1.0, y: 1.0),
     Soldier(name: "c", team: 1, hp: 7.0, x: 5.0, y: 5.0),
@@ -48,70 +48,70 @@ fun army() -> List[Soldier] =
   )
 test "seq_method_filter: a List has no filter of its own, so Seq.filter is used"
-  xs := List(1, 2, 3, 4, 5, 6)
+  xs := Slice(1, 2, 3, 4, 5, 6)
   evens := for x := range xs.filter()
     x % 2 == 0
   assert evens.length() == 3
   assert evens.at(2) == 6
 test "adapter take"
-  xs := List(5, 6, 7, 8)
+  xs := Slice(5, 6, 7, 8)
   got := for x := range xs.take(2).map()
     x * 10
   assert got.length() == 2
   assert got.at(1) == 60
 test "adapter skip"
-  xs := List(5, 6, 7, 8)
+  xs := Slice(5, 6, 7, 8)
   n := 0
   for x := range xs.skip(2)
     n = n * 10 + x
   assert n == 78
 test "adapter stepBy"
-  xs := List(1, 2, 3, 4, 5, 6, 7)
+  xs := Slice(1, 2, 3, 4, 5, 6, 7)
   n := for x := range xs.stepBy(3).count()
     true
   assert n == 3
 test "adapter zip"
-  xs := List(1, 2, 3)
+  xs := Slice(1, 2, 3)
-  ys := List(10, 20, 30, 40)
+  ys := Slice(10, 20, 30, 40)
   dot := 0
   for a, b := range xs.zip(ys)
     dot = dot + a * b
   assert dot == 140
 test "adapter reversed"
-  xs := List(1, 2, 3)
+  xs := Slice(1, 2, 3)
   n := 0
   for x := range xs.reversed()
     n = n * 10 + x
   assert n == 321
 test "adapter chunks"
-  xs := List(1, 2, 3, 4, 5)
+  xs := Slice(1, 2, 3, 4, 5)
   sizes := for c := range xs.chunks(2).map()
     c.length()
   assert sizes.length() == 3
   assert sizes.at(2) == 1
 test "seq_chain_take_filter_fused: take then filter"
-  xs := List(1, 2, 3, 4, 5, 6, 7, 8)
+  xs := Slice(1, 2, 3, 4, 5, 6, 7, 8)
   got := for x := range xs.take(6).filter(), if x > 1
     x % 2 == 0
   assert got.length() == 3
   assert got.at(0) == 2
 test "terminal map with clauses"
-  xs := List(1, 2, 3, 4)
+  xs := Slice(1, 2, 3, 4)
   got := for x := range xs.map(), if x % 2 == 1, sq := x * x
     sq + 1
   assert got.length() == 2
   assert got.at(1) == 10
 test "terminal find"
-  xs := List(3, 8, 12)
+  xs := Slice(3, 8, 12)
   big := for x := range xs.find()
     x > 5
   b := big ?: 0
@@ -122,13 +122,13 @@ test "terminal find"
   assert c == -1
 test "terminal fold"
-  xs := List(1, 2, 3, 4)
+  xs := Slice(1, 2, 3, 4)
   sum := for acc, x := range xs.fold(100)
     acc + x
   assert sum == 110
 test "terminals count any all each"
-  xs := List(1, 2, 3, 4)
+  xs := Slice(1, 2, 3, 4)
   n := for x := range xs.count()
     x > 1
   assert n == 3
@@ -144,7 +144,7 @@ test "terminals count any all each"
   assert seen == 10
 test "firstN_predicate: the first n elements the body accepts"
-  xs := List(1, 2, 3, 4, 5, 6, 7, 8)
+  xs := Slice(1, 2, 3, 4, 5, 6, 7, 8)
   got := for x := range xs.firstN(3)
     x % 2 == 0
   assert got.length() == 3
@@ -154,7 +154,7 @@ test "firstN_predicate: the first n elements the body accepts"
   assert few.length() == 2
 test "toList_no_body: a chain ends in a List without a for"
-  xs := List(1, 2, 3, 4, 5)
+  xs := Slice(1, 2, 3, 4, 5)
   ys := xs.skip(1).take(3).toList()
   assert ys.length() == 3
   assert ys.at(0) == 2

plum-examples/strings.plum CHANGED Viewed

@@ -3,7 +3,7 @@
 import std/Int
 import std/Float
 import std/Str
-import std/List
+import std/Slice
 fun greet(name: Str) -> Str =
   "Hello, {name}!"
@@ -57,7 +57,7 @@ test "string interpolation supports a boolean expression, not just a bare variab
 test "string interpolation supports a method call taking a closure literal"
-  l := List(1, 2, 3, 4)
+  l := Slice(1, 2, 3, 4)
   assert "{l.findValue(3)!}" == "3"
   assert "{l.contains(100)}" == "false"

plum-examples/struct_arrays.plum CHANGED Viewed

@@ -1,12 +1,12 @@
 # Arrays of structs are stored field by field (struct-of-arrays): `Array[Vec2]`
 # is one object holding an `f64` array for `x` and one for `y`, so `get`/`set`
-# allocate nothing per element. `List`, `Grid` and friends get this for free.
+# allocate nothing per element. `Slice`, `Grid` and friends get this for free.
 module struct_arrays
 import std/Str
 import std/Int
 import std/Float
 import std/Array
-import std/List
+import std/Slice
 import std/Grid
 struct Vec2(x: Float, y: Float)
@@ -18,7 +18,7 @@ struct Rect(pos: Vec2, size: Vec2) =
 struct Tile(id: Int, solid: Bool, weight: Float)
-record World(points: List[Vec2], name: Str)
+record World(points: Slice[Vec2], name: Str)
 struct One(n: Int)
 struct Flags(a: Bool, b: Bool, c: Int)
@@ -41,7 +41,7 @@ fun mkPx(v: Int) -> Px =
   Px(r: Byte(v), g: Byte(v + 1), b: Byte(v + 2), a: Byte(255))
 test "List[Vec2] push/get/set round-trips across growth"
-  l := List[Vec2]()
+  l := Slice[Vec2]()
   for i := range 100
     l.push(Vec2(x: Float(i), y: Float(i) * 2.0))
   assert l.length() == 100
@@ -86,7 +86,7 @@ test "struct with Int, Bool and Float leaves"
   assert !b.get(3).solid
 test "copy semantics: a value read from the array is a copy until set"
-  l := List[Vec2]()
+  l := Slice[Vec2]()
   l.push(Vec2(x: 1.0, y: 1.0))
   v := l.get(0)!
   v = Vec2(x: 99.0, y: 99.0)
@@ -121,7 +121,7 @@ test "Grid[Tile] get/set"
   assert g.get(1, 1).weight == 0.5
 test "a List[Vec2] inside a record field"
-  w := World(points: List[Vec2](), name: "w")
+  w := World(points: Slice[Vec2](), name: "w")
   w.points.push(Vec2(x: 1.0, y: 2.0))
   w.points.push(Vec2(x: 3.0, y: 4.0))
   assert w.points.length() == 2
@@ -171,7 +171,7 @@ test "probe generic first, equality"
 test "probe nullable and list and error"
   n: Array[Vec2]? := Array[Vec2]().push(Vec2(x: 3.0, y: 3.0))
   assert n!.get(0).x == 3.0
-  l := List[Array[Vec2]]()
+  l := Slice[Array[Vec2]]()
   l.push(Array[Vec2]().push(Vec2(x: 4.0, y: 4.0)))
   assert l.get(0)!.get(0).x == 4.0
   r := mk()!
@@ -203,7 +203,7 @@ test "Byte struct fields: copy, compare, store"
   a := Array[Px]().push(p).push(mkPx(20))
   assert a.get(1).g == Byte(21)
   assert a.get(0) == q
-  l := List[Px]()
+  l := Slice[Px]()
   for i := range 50
     l.push(mkPx(i))
   assert l.get(37)!.b == Byte(39)

plum-examples/struct_union_members.plum CHANGED Viewed

@@ -6,7 +6,7 @@ module struct_union_members
 import std/Str
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 enum Step = Move | Wait | Chain
@@ -14,7 +14,7 @@ struct Move(dx: Float, left: Float)
 struct Wait(left: Float)
-record Chain(steps: List[Step])
+record Chain(steps: Slice[Step])
 trait Thing(x: Float, tag: Int) =
   fun clone(self) -> Thing
@@ -39,7 +39,7 @@ fun copyOut(s: Step) -> Move =
     _ => Move(dx: 0.0, left: 0.0)
 test "struct_member_through_list"
-  steps: List[Step] := List[Step]()
+  steps: Slice[Step] := Slice[Step]()
   steps.push(Move(1.0, 2.0))
   steps.push(Wait(3.0))
   c := Chain(steps: steps)
@@ -53,7 +53,7 @@ test "struct_member_spread_copy"
   assert m.left == 2.0
 test "struct_member_match_copy_is_independent"
-  steps: List[Step] := List[Step]()
+  steps: Slice[Step] := Slice[Step]()
   steps.push(Move(dx: 1.0, left: 2.0))
   mv := copyOut(steps.at(0))
   mv.left = 9.0

plum-examples/structs_records.plum CHANGED Viewed

@@ -118,7 +118,7 @@ record Slab(bounds: Rect, id: Int)
 record Bag(n: Int) =
   fun init(self) =
     self.label = "bag"
-    self.items: List[Int] = List[Int]()
+    self.items: Slice[Int] = Slice[Int]()
     self.cap: Int = self.n * 2
 # ---- embedding records and override ----

plum-examples/tail_calls.plum CHANGED Viewed

@@ -6,27 +6,27 @@
 module tail_calls
 import std/Int
 import std/Float
+import std/List
-enum Link[T] = Nil | Cons(head: T, tail: Link[T])
 fun sumTo(n: Int, acc: Int) -> Int =
   if n == 0 then acc else sumTo(n - 1, acc + n)
-fun build(n: Int, acc: Link[Int]) -> Link[Int] =
+fun build(n: Int, acc: List[Int]) -> List[Int] =
   if n == 0 then acc else build(n - 1, Cons(head: n, tail: acc))
-fun fromTo(a: Int, b: Int) -> Link[Int] =
+fun fromTo(a: Int, b: Int) -> List[Int] =
   if a >= b then Nil else Cons(head: a, tail: fromTo(a + 1, b))
-fun map(xs: Link[A], f: fn(A) -> B) -> Link[B] = match xs
+fun map(xs: List[A], f: fn(A) -> B) -> List[B] = match xs
   Nil => Nil
   Cons(h, t) => Cons(head: f(h), tail: map(t, f))
-fun foldl(xs: Link[T], acc: A, f: fn(A, T) -> A) -> A = match xs
+fun foldl(xs: List[T], acc: A, f: fn(A, T) -> A) -> A = match xs
   Nil => acc
   Cons(h, t) => foldl(t, f(acc, h), f)
-fun length(xs: Link[T], acc: Int) -> Int = match xs
+fun length(xs: List[T], acc: Int) -> Int = match xs
   Nil => acc
   Cons(_, t) => length(t, acc + 1)

plum-examples/trait_scene.plum CHANGED Viewed

@@ -1,9 +1,9 @@
-# A tiny pure scene: a `Scene` holds `List[Entity]`; the engine side knows only
+# A tiny pure scene: a `Scene` holds `Slice[Entity]`; the engine side knows only
 # the trait, the records fill it in. No game host needed.
 module trait_scene
 import std/Str
 import std/Int
-import std/List
+import std/Slice
 trait Entity(x: Int, y: Int) =
   fun update(self, dt: Int)
@@ -20,7 +20,7 @@ record Walker(Entity(x, y), speed: Int) =
     self.x = self.x + self.speed * dt
   override fun draw(self) -> Int = self.x
-record Scene(entities: List[Entity]) =
+record Scene(entities: Slice[Entity]) =
   fun update(self, dt: Int) =
     for e := range self.entities
       e.update(dt)
@@ -31,7 +31,7 @@ record Scene(entities: List[Entity]) =
     total
 fun makeScene() -> Scene =
-  es: List[Entity] := List[Entity]()
+  es: Slice[Entity] := Slice[Entity]()
   es.push(House(x: 0, y: 0, floors: 2))
   es.push(Walker(x: 3, y: 1, speed: 2))
   Scene(entities: es)

plum-examples/traits.plum CHANGED Viewed

@@ -8,7 +8,7 @@ module traits
 import std/Str
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 struct Vec2(x: Int, y: Int) =
   fun add(self, o: Vec2) -> Vec2 = Vec2(x: self.x + o.x, y: self.y + o.y)
@@ -62,7 +62,7 @@ test "fields_through_trait"
   assert h.z == 4
 test "list_of_entities_dispatch"
-  es: List[Entity] := List[Entity]()
+  es: Slice[Entity] := Slice[Entity]()
   es.push(house())
   es.push(tree())
   assert es.at(0).update(2) == 6

plum-examples/unboxed_variants.plum ADDED Viewed

@@ -0,0 +1,337 @@
+# Probes for unboxed variants (union-enum members and inline variants are
+# subtypes of the enum): deep nesting, Json round trips, toStr, a million-long
+# List of unions, member mutation, reassignment across members, own record
+# members, and enum `init` versus variant-name resolution.
+module unboxed_variants
+import std/Str
+import std/Int
+import std/Float
+import std/Json
+import std/Slice
+import std/List
+# Six levels of unions, each wrapping the one below.
+record Leaf(v: Int) =
+  fun toJson(self) -> Json = Json.object("v" => self.v.toJson())
+  fun fromJson(j: Json) -> JsonError!Leaf =
+    return Leaf(v: try Int.fromJson(try j.field("v")))
+  fun toStr(self) -> Str = "L{self.v}"
+record Stub(n: Int) =
+  fun toJson(self) -> Json = Json.object("n" => self.n.toJson())
+  fun fromJson(j: Json) -> JsonError!Stub =
+    return Stub(n: try Int.fromJson(try j.field("n")))
+  fun toStr(self) -> Str = "S{self.n}"
+enum U0 = Leaf | Stub
+record W1(in: U0) =
+  fun toJson(self) -> Json = Json.object("in" => self.in.toJson())
+  fun fromJson(j: Json) -> JsonError!W1 =
+    return W1(in: try u0Of(try j.field("in")))
+  fun toStr(self) -> Str = "W1({self.in})"
+record Z1(k: Int) =
+  fun toJson(self) -> Json = Json.object("k" => self.k.toJson())
+  fun fromJson(j: Json) -> JsonError!Z1 =
+    return Z1(k: try Int.fromJson(try j.field("k")))
+  fun toStr(self) -> Str = "Z1"
+enum U1 = W1 | Z1
+record W2(in: U1) =
+  fun toJson(self) -> Json = Json.object("in" => self.in.toJson())
+  fun fromJson(j: Json) -> JsonError!W2 =
+    return W2(in: try u1Of(try j.field("in")))
+  fun toStr(self) -> Str = "W2({self.in})"
+record Z2(k: Int) =
+  fun toJson(self) -> Json = Json.object("k" => self.k.toJson())
+  fun toStr(self) -> Str = "Z2"
+enum U2 = W2 | Z2
+record W3(in: U2) =
+  fun toJson(self) -> Json = Json.object("in" => self.in.toJson())
+  fun fromJson(j: Json) -> JsonError!W3 =
+    return W3(in: try u2Of(try j.field("in")))
+  fun toStr(self) -> Str = "W3({self.in})"
+record Z3(k: Int) =
+  fun toJson(self) -> Json = Json.object("k" => self.k.toJson())
+  fun toStr(self) -> Str = "Z3"
+enum U3 = W3 | Z3
+record W4(in: U3) =
+  fun toJson(self) -> Json = Json.object("in" => self.in.toJson())
+  fun fromJson(j: Json) -> JsonError!W4 =
+    return W4(in: try u3Of(try j.field("in")))
+  fun toStr(self) -> Str = "W4({self.in})"
+record Z4(k: Int) =
+  fun toJson(self) -> Json = Json.object("k" => self.k.toJson())
+  fun toStr(self) -> Str = "Z4"
+enum U4 = W4 | Z4
+record W5(in: U4) =
+  fun toJson(self) -> Json = Json.object("in" => self.in.toJson())
+  fun fromJson(j: Json) -> JsonError!W5 =
+    return W5(in: try u4Of(try j.field("in")))
+  fun toStr(self) -> Str = "W5({self.in})"
+record Z5(k: Int) =
+  fun toJson(self) -> Json = Json.object("k" => self.k.toJson())
+  fun toStr(self) -> Str = "Z5"
+enum U5 = W5 | Z5
+# Decoders: the union itself cannot be decoded, so decode the member that was
+# encoded (every level here is a W, whose `in` is the only field).
+fun u0Of(j: Json) -> JsonError!U0 =
+  l: JsonError!Leaf := j.into()
+  return l!
+fun u1Of(j: Json) -> JsonError!U1 =
+  w: JsonError!W1 := j.into()
+  return w!
+fun u2Of(j: Json) -> JsonError!U2 =
+  w: JsonError!W2 := j.into()
+  return w!
+fun u3Of(j: Json) -> JsonError!U3 =
+  w: JsonError!W3 := j.into()
+  return w!
+fun u4Of(j: Json) -> JsonError!U4 =
+  w: JsonError!W4 := j.into()
+  return w!
+fun deepLeaf(v: Int) -> U5 =
+  l0: U0 := Leaf(v: v)
+  l1: U1 := W1(in: l0)
+  l2: U2 := W2(in: l1)
+  l3: U3 := W3(in: l2)
+  l4: U4 := W4(in: l3)
+  W5(in: l4)
+fun deepStub(n: Int) -> U5 =
+  l0: U0 := Stub(n: n)
+  l1: U1 := W1(in: l0)
+  l2: U2 := W2(in: l1)
+  l3: U3 := W3(in: l2)
+  l4: U4 := W4(in: l3)
+  W5(in: l4)
+fun dig(u: U5) -> Int =
+  match u
+    W5(a) =>
+      match a
+        W4(b) =>
+          match b
+            W3(c) =>
+              match c
+                W2(d) =>
+                  match d
+                    W1(e) =>
+                      match e
+                        Leaf(v) => v
+                        Stub(n) => -n
+                    Z1(k) => 1000 + k
+                Z2(k) => 2000 + k
+            Z3(k) => 3000 + k
+        Z4(k) => 4000 + k
+    Z5(k) => 5000 + k
+fun roundTrip(v: Int) -> Int =
+  u := deepLeaf(v)
+  text := Json.encode(u)
+  back: JsonError!W5 := Json.decode(text)
+  if Json.encode(back!) == text then 1 else 0
+fun leaves(n: Int) -> List[Int] =
+  if n == 0 then Nil else Cons(head: n, tail: leaves(n - 1))
+# State.
+record Circle(r: Float)
+record Rect(w: Float, h: Float)
+enum Shape = Circle | Rect
+struct Disc(r: Float)
+enum Round = Disc | Rect
+fun roundArea(m: Round) -> Float =
+  match m
+    Disc(r) => r * r * 3.0
+    Rect(w, h) => w * h
+fun area(s: Shape) -> Float =
+  match s
+    Circle(r) => r * r * 3.0
+    Rect(w, h) => w * h
+fun kind(s: Shape) -> Int =
+  match s
+    Circle(_) => 1
+    Rect(_, _) => 10
+own record Token(id: Int)
+own record Stamp(id: Int, note: Str)
+enum Mark = Token | Stamp
+fun takeMark(own m: Mark) -> Mark = m
+fun markId(m: Mark) -> Int =
+  match m
+    Token(id) => id
+    Stamp(id, _) => id + 1000
+# Enum `init` versus variant names.
+enum Cell =
+  | Empty
+  | Full(count: Int, label: Str)
+  fun init(n: Int) -> Cell = if n <= 0 then Empty else Full(count: n, label: "n{n}")
+  fun size(self) -> Int =
+    match self
+      Empty => 0
+      Full(c, _) => c
+fun describe(c: Cell) -> Str =
+  match c
+    Full(n, l) => "{n}{l}"
+    Empty => "empty"
+test "deep_nested_match"
+  assert dig(deepLeaf(42)) == 42
+  assert dig(deepStub(7)) == -7
+  assert dig(Z5(k: 1)) == 5001
+  z4: U4 := Z4(k: 2)
+  assert dig(W5(in: z4)) == 4002
+  z3: U3 := Z3(k: 3)
+  w4: U4 := W4(in: z3)
+  assert dig(W5(in: w4)) == 3003
+  z2: U2 := Z2(k: 4)
+  w3: U3 := W3(in: z2)
+  w4b: U4 := W4(in: w3)
+  assert dig(W5(in: w4b)) == 2004
+  z1: U1 := Z1(k: 5)
+  w2: U2 := W2(in: z1)
+  w3b: U3 := W3(in: w2)
+  w4c: U4 := W4(in: w3b)
+  assert dig(W5(in: w4c)) == 1005
+test "deep_toStr"
+  assert deepLeaf(9).toStr() == "W5(W4(W3(W2(W1(L9)))))"
+  assert "{deepStub(3)}" == "W5(W4(W3(W2(W1(S3)))))"
+test "deep_json_round_trip"
+  u := deepLeaf(5)
+  text := Json.encode(u)
+  assert text == "{{\"in\":{{\"in\":{{\"in\":{{\"in\":{{\"in\":{{\"v\":5.0}}}}}}}}}}}}"
+  back: JsonError!W5 := Json.decode(text)
+  assert back!.toStr() == "W5(W4(W3(W2(W1(L5)))))"
+  assert Json.encode(back!) == text
+  assert roundTrip(77) == 1
+# A list of union values, a million long, mapped and folded in constant stack.
+test "deep_list_of_unions_million"
+  xs := leaves(1000000).map(|n| deepLeaf(n))
+  assert xs.length() == 1000000
+  total := xs.fold(0, |acc, u| acc + dig(u))
+  assert total == 500000500000
+  small := List(deepLeaf(1), deepStub(2)).map(|u| dig(u))
+  assert small.toStr() == "[1,-2]"
+test "member_field_mutation_visible"
+  c := Circle(r: 1.0)
+  c.r = 4.0
+  s: Shape := c
+  assert area(s) == 48.0
+  r := Rect(w: 2.0, h: 3.0)
+  s2: Shape := r
+  r.w = 10.0
+  assert area(s2) == 30.0
+  d := Disc(r: 1.0)
+  m: Round := d
+  d.r = 9.0
+  assert roundArea(m) == 3.0
+  assert d.r == 9.0
+  r.w = 1.0
+  assert area(s2) == 3.0
+test "member_field_assigned_after_narrowing"
+  s: Shape := Rect(w: 2.0, h: 3.0)
+  if Rect := s
+    s.w = 7.0
+  assert area(s) == 21.0
+  t: Shape := Circle(r: 1.0)
+  if Circle := t
+    t.r = 2.0
+  assert area(t) == 12.0
+test "reassign_union_local_across_members"
+  s: Shape := Circle(r: 1.0)
+  assert area(s) == 3.0
+  s = Rect(w: 2.0, h: 5.0)
+  assert area(s) == 10.0
+  s = Circle(r: 2.0)
+  assert area(s) == 12.0
+  n := 0
+  for i := range 4
+    if i % 2 == 0
+      s = Rect(w: 1.0, h: 1.0)
+    else
+      s = Circle(r: 1.0)
+    n = n + kind(s)
+  assert n == 22
+test "own_record_member_moves"
+  t := Token(id: 3)
+  m: Mark := takeMark(t)
+  assert markId(m) == 3
+  s := Stamp(id: 4, note: "x")
+  m2: Mark := takeMark(s)
+  assert markId(m2) == 1004
+  m3 := takeMark(m2)
+  assert markId(m3) == 1004
+test "init_and_variant_name_resolution"
+  a := Cell(5)
+  assert a.size() == 5
+  b := Cell(0)
+  assert b.size() == 0
+  c := Full(count: 9, label: "nine")
+  assert c.size() == 9
+  d := Full(label: "swapped", count: 2)
+  assert d.size() == 2
+  e: Cell := Full(label: "q", count: 7)
+  assert describe(e) == "7q"

plum-examples/unions.plum CHANGED Viewed

@@ -2,7 +2,7 @@
 # A member converts to the enum where one is expected, a bare member name in a
 # pattern narrows the subject, and a method every member defines is callable on
 # the enum (auto-dispatch). Members can be structs, records, primitives
-# (`Int | Float | Str`), generic instances (`List[Jv]`) or bare tags. An enum
+# (`Int | Float | Str`), generic instances (`Slice[Jv]`) or bare tags. An enum
 # can also define its own methods (a `match self` body), carry a shared
 # discriminant field (`enum Step(n: Int)`), and one type can belong to several
 # enums.
@@ -10,7 +10,7 @@ module unions
 import std/Str
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 struct Circle(r: Float) =
   fun area(self) -> Float = self.r * self.r * 3.0
@@ -32,7 +32,7 @@ record Leaf(v: Int)
 record Node[T](left: Tree[T], right: Tree[T])
-enum Jv = JvNull | Int | Float | Str | List[Jv]
+enum Jv = JvNull | Int | Float | Str | Slice[Jv]
 fun total(t: Tree[Int]) -> Int =
   match t
@@ -49,7 +49,7 @@ fun describeJv(j: Jv) -> Str =
     Int => "int"
     Float => "float"
     Str => "str {j}"
-    List => "list"
+    Slice => "list"
 fun areaOf(s: Shape) -> Float = s.area()
@@ -115,7 +115,7 @@ fun describeMatch(b: Book) -> Str =
     Novel(title, _) => "novel {title}"
     Atlas(title, _) => "atlas {title}"
-enum Jb = BNull | Bool | Float | Str | List[Jb]
+enum Jb = BNull | Bool | Float | Str | Slice[Jb]
 fun showB(j: Jb) -> Str =
   match j
@@ -123,12 +123,12 @@ fun showB(j: Jb) -> Str =
     Bool => if j then "T" else "F"
     Float => "f"
     Str => "s"
-    List => "l"
+    Slice => "l"
-fun pos(n: Int) -> !List[Jv] =
+fun pos(n: Int) -> !Slice[Jv] =
   if n < 0
     return error.Neg
-  xs := List[Jv]()
+  xs := Slice[Jv]()
   xs.push(n)
   xs.push("a")
   xs
@@ -148,7 +148,7 @@ test "struct_member_copy"
     assert false
 test "list_of_shapes"
-  xs := List[Shape]()
+  xs := Slice[Shape]()
   xs.push(Circle(r: 1.0))
   xs.push(Rectangle(w: 2.0, h: 3.0))
   sum := 0.0
@@ -164,7 +164,7 @@ test "json_like_primitives"
   assert describeJv(7) == "int"
   assert describeJv(1.5) == "float"
   assert describeJv("hi") == "str hi"
-  js := List[Jv]()
+  js := Slice[Jv]()
   js.push(1.0)
   js.push(7)
   assert describeJv(js) == "list"
@@ -196,11 +196,11 @@ test "bool_member"
 test "union_in_try"
   assert {posLen(3) catch 0} == 2
   assert {posLen(-1) catch 0} == 0
-  ys := pos(3) catch List[Jv]()
+  ys := pos(3) catch Slice[Jv]()
   assert describeJv(ys) == "list"
 test "union_with_for"
-  xs := List[Jv]()
+  xs := Slice[Jv]()
   xs.push(1)
   xs.push("a")
   xs.push(2.5)
@@ -226,7 +226,7 @@ test "enum defines its own method over its members"
   assert b.area() == 2.0
 test "Book both ways: auto-dispatch and match agree"
-  books: List[Book] := List[Book]()
+  books: Slice[Book] := Slice[Book]()
   books.push(Novel(title: "Dune", pages: 600))
   books.push(Atlas(title: "World", regions: 7))
   for b := range books

plum-game/web-test/fixtures/stress_pure_scene.plum CHANGED Viewed

@@ -8,7 +8,7 @@ module stress_pure_scene
 import std/Str
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 import std/game/Vec2
 import std/game/Color
 import std/game/Affine
@@ -74,7 +74,7 @@ fun drifter(id: Int, tex: Int, c: Color, x: Float, y: Float, w: Float, h: Float,
   d := Drifter(
     id: id, x: x, y: y, width: w, height: h, originX: 0.0, originY: 0.0,
     scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: c, visible: true,
-    touchable: Disabled, actions: List[Action](), tex: tex, dx: dx, dy: dy)
+    touchable: Disabled, actions: Slice[Action](), tex: tex, dx: dx, dy: dy)
   me: Actor := d
   me
@@ -82,12 +82,12 @@ fun countLabel(id: Int, n: Int, x: Float, y: Float) -> Actor =
   l := CountLabel(
     id: id, x: x, y: y, width: 60.0, height: 14.0, originX: 0.0, originY: 0.0,
     scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: Color.White, visible: true,
-    touchable: Disabled, actions: List[Action](), n: n, text: "n {n}")
+    touchable: Disabled, actions: Slice[Action](), n: n, text: "n {n}")
   me: Actor := l
   me
-fun spinning(rate: Float) -> List[Action] =
+fun spinning(rate: Float) -> Slice[Action] =
-  acts := List[Action]()
+  acts := Slice[Action]()
   acts.push(Actions.forever(Actions.rotateBy(rate, 1.0)))
   acts
@@ -104,10 +104,10 @@ fun dancer(id: Int, sheet: Int, j: Int, i: Int) -> Actor =
   me
 fun buildWorld(sheet: Int, white: Int) -> World =
-  root := List[Actor]()
+  root := Slice[Actor]()
   per := Counts.Sprites / Counts.Groups
   for gi := range Counts.Groups
-    kids := List[Actor]()
+    kids := Slice[Actor]()
     for j := range per
       i := gi * per + j
       kids.push(dancer(1000 + i, sheet, j, i))
@@ -138,7 +138,7 @@ export fun init() -> World =
   buildWorld(textureLoad("sprites.png"), whiteTexture())
 fun frameStage(own s: Stage, dt: Float) -> Stage =
-  s.frame(dt, List[Input]()).intoStage()
+  s.frame(dt, Slice[Input]()).intoStage()
 export fun update(w: World, dt: Float) =
   w.stage = frameStage(w.stage, dt)

plum-game/web-test/fixtures/stress_scene.plum CHANGED Viewed

@@ -6,7 +6,7 @@ module stress_scene
 import std/Str
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 import std/game/Vec2
 import std/game/Color
 import std/game/Game

plum-game/web-test/fixtures/stress_state_view.plum CHANGED Viewed

@@ -1,7 +1,7 @@
 # The stress scene of stress_pure_scene.plum written as state and view, now recursive:
 # 5000 sprites in 50 slowly rotating groups, 500 rects and 200 circles (sprites of a
 # 1x1 white texture), 50 texts with a changing number, drawn through a 0.8 camera.
-# `State` is recursive `Link` lists (each spinner owns the `Link` of its 100 dancers);
+# `State` is cons `List` lists (each spinner owns the `List` of its 100 dancers);
 # `step` is pure, a structural recursion that returns the next state; `view` is pure
 # and rebuilds the whole SceneNode tree every frame with recursive functions, which
 # `Picture.draw` interprets. Nothing is retained between frames but `State`. The
@@ -10,6 +10,7 @@ module stress_state_view
 import std/Str
 import std/Int
 import std/Float
+import std/Slice
 import std/List
 import std/game/Vec2
 import std/game/Color
@@ -25,39 +26,38 @@ primitive Counts =
   WorldW = 1600
   WorldH = 900
-enum Link[T] = Nil | Cons(head: T, tail: Link[T])
-fun mapLink(xs: Link[A], f: fn(A) -> B) -> Link[B] = match xs
+fun mapLink(xs: List[A], f: fn(A) -> B) -> List[B] = match xs
   Nil => Nil
   Cons(h, t) => Cons(head: f(h), tail: mapLink(t, f))
 # The list f(i), f(i + 1) ... f(n - 1).
-fun rangeLink(i: Int, n: Int, f: fn(Int) -> T) -> Link[T] =
+fun rangeLink(i: Int, n: Int, f: fn(Int) -> T) -> List[T] =
   if i >= n then Nil else Cons(head: f(i), tail: rangeLink(i + 1, n, f))
-fun appendLink(xs: Link[T], ys: Link[T]) -> Link[T] = match xs
+fun appendLink(xs: List[T], ys: List[T]) -> List[T] = match xs
   Nil => ys
   Cons(h, t) => Cons(head: h, tail: appendLink(t, ys))
 # The element at `i`, or `dflt` past the end.
-fun nthOr(xs: Link[T], i: Int, dflt: T) -> T = match xs
+fun nthOr(xs: List[T], i: Int, dflt: T) -> T = match xs
   Nil => dflt
   Cons(h, t) => if i <= 0 then h else nthOr(t, i - 1, dflt)
 # The nodes f(x) for every x of `xs`, followed by `rest`.
-fun toNodes(xs: Link[T], f: fn(T) -> SceneNode, rest: Nodes) -> Nodes = match xs
+fun toNodes(xs: List[T], f: fn(T) -> SceneNode, rest: List[SceneNode]) -> List[SceneNode] = match xs
   Nil => rest
-  Cons(h, t) => More(head: f(h), tail: toNodes(t, f, rest))
+  Cons(h, t) => Cons(head: f(h), tail: toNodes(t, f, rest))
-fun countNodes(ns: Nodes) -> Int = match ns
+fun countNodes(ns: List[SceneNode]) -> Int = match ns
-  End => 0
+  Nil => 0
-  More(_, t) => 1 + countNodes(t)
+  Cons(_, t) => 1 + countNodes(t)
 # A sprite of the sheet inside its group, spinning about its centre.
 struct Dancer(id: Int, x: Float, y: Float, rotation: Float, srcX: Float)
 # A rotating group of dancers: top-left (x, y), pivot (75, 85).
-record Spinner(id: Int, x: Float, y: Float, rotation: Float, dancers: Link[Dancer])
+record Spinner(id: Int, x: Float, y: Float, rotation: Float, dancers: List[Dancer])
 # A square of the white texture that moves by (dx, dy) per frame and wraps.
 struct Drifter(id: Int, x: Float, y: Float, w: Float, h: Float, dx: Float, dy: Float, color: Color)
@@ -65,7 +65,7 @@ struct Drifter(id: Int, x: Float, y: Float, w: Float, h: Float, dx: Float, dy: F
 # Shows "n <count>" and counts up each frame.
 struct Counter(id: Int, x: Float, y: Float, n: Int)
-record State(sheet: Int, white: Int, spinners: Link[Spinner], drifters: Link[Drifter], counters: Link[Counter])
+record State(sheet: Int, white: Int, spinners: List[Spinner], drifters: List[Drifter], counters: List[Counter])
 fun hue(i: Int) -> Color =
   Color(r: Float(i % 7) / 7.0, g: Float(i % 5) / 5.0, b: 0.4 + Float(i % 3) / 5.0, a: 0.8)
@@ -118,14 +118,14 @@ fun step(s: State, dt: Float) -> State =
 fun dancerView(sheet: Int, d: Dancer) -> SceneNode =
   Group(
     transform: Compose(first: Translate(dx: d.x + 8.0, dy: d.y + 8.0), then: Compose(first: Rotate(radians: d.rotation), then: Translate(dx: 0.0 - 8.0, dy: 0.0 - 8.0))),
-    children: More(head: Sprite(
+    children: Cons(head: Sprite(
       tex: sheet, x: 0.0, y: 0.0, w: 16.0, h: 16.0, srcX: d.srcX, srcY: 0.0, srcW: 16.0, srcH: 16.0,
-      tint: Color.White), tail: End))
+      tint: Color.White), tail: Nil))
 fun spinnerView(sheet: Int, p: Spinner) -> SceneNode =
   Group(
     transform: Compose(first: Translate(dx: p.x + 75.0, dy: p.y + 85.0), then: Compose(first: Rotate(radians: p.rotation), then: Translate(dx: 0.0 - 75.0, dy: 0.0 - 85.0))),
-    children: toNodes(p.dancers, |d| dancerView(sheet, d), End))
+    children: toNodes(p.dancers, |d| dancerView(sheet, d), Nil))
 fun drifterView(white: Int, d: Drifter) -> SceneNode =
   Sprite(
@@ -136,7 +136,7 @@ fun counterView(c: Counter) -> SceneNode =
   Text(text: "n {c.n}", x: c.x, y: c.y, size: 14.0, color: Color.White)
 fun view(s: State) -> SceneNode =
-  texts := toNodes(s.counters, |c| counterView(c), End)
+  texts := toNodes(s.counters, |c| counterView(c), Nil)
   drifts := toNodes(s.drifters, |d| drifterView(s.white, d), texts)
   Group(transform: Scale(sx: 0.8, sy: 0.8), children: toNodes(s.spinners, |p| spinnerView(s.sheet, p), drifts))

plum-game/web-test/fixtures/stress_state_view_deep.plum CHANGED Viewed

@@ -1,9 +1,9 @@
-# Variant of stress_state_view.plum: all 5000 dancers live in ONE Link (each records its
+# Variant of stress_state_view.plum: all 5000 dancers live in ONE List (each records its
 # spinner index), so step recurses 5000 deep. Original header follows.
 # The stress scene of stress_pure_scene.plum written as state and view, now recursive:
 # 5000 sprites in 50 slowly rotating groups, 500 rects and 200 circles (sprites of a
 # 1x1 white texture), 50 texts with a changing number, drawn through a 0.8 camera.
-# `State` is recursive `Link` lists (each spinner owns the `Link` of its 100 dancers);
+# `State` is cons `List` lists (each spinner owns the `List` of its 100 dancers);
 # `step` is pure, a structural recursion that returns the next state; `view` is pure
 # and rebuilds the whole SceneNode tree every frame with recursive functions, which
 # `Picture.draw` interprets. Nothing is retained between frames but `State`. The
@@ -12,6 +12,7 @@ module stress_state_view
 import std/Str
 import std/Int
 import std/Float
+import std/Slice
 import std/List
 import std/game/Vec2
 import std/game/Color
@@ -27,33 +28,32 @@ primitive Counts =
   WorldW = 1600
   WorldH = 900
-enum Link[T] = Nil | Cons(head: T, tail: Link[T])
-fun mapLink(xs: Link[A], f: fn(A) -> B) -> Link[B] = match xs
+fun mapLink(xs: List[A], f: fn(A) -> B) -> List[B] = match xs
   Nil => Nil
   Cons(h, t) => Cons(head: f(h), tail: mapLink(t, f))
 # The list f(i), f(i + 1) ... f(n - 1).
-fun rangeLink(i: Int, n: Int, f: fn(Int) -> T) -> Link[T] =
+fun rangeLink(i: Int, n: Int, f: fn(Int) -> T) -> List[T] =
   if i >= n then Nil else Cons(head: f(i), tail: rangeLink(i + 1, n, f))
-fun appendLink(xs: Link[T], ys: Link[T]) -> Link[T] = match xs
+fun appendLink(xs: List[T], ys: List[T]) -> List[T] = match xs
   Nil => ys
   Cons(h, t) => Cons(head: h, tail: appendLink(t, ys))
 # The element at `i`, or `dflt` past the end.
-fun nthOr(xs: Link[T], i: Int, dflt: T) -> T = match xs
+fun nthOr(xs: List[T], i: Int, dflt: T) -> T = match xs
   Nil => dflt
   Cons(h, t) => if i <= 0 then h else nthOr(t, i - 1, dflt)
 # The nodes f(x) for every x of `xs`, followed by `rest`.
-fun toNodes(xs: Link[T], f: fn(T) -> SceneNode, rest: Nodes) -> Nodes = match xs
+fun toNodes(xs: List[T], f: fn(T) -> SceneNode, rest: List[SceneNode]) -> List[SceneNode] = match xs
   Nil => rest
-  Cons(h, t) => More(head: f(h), tail: toNodes(t, f, rest))
+  Cons(h, t) => Cons(head: f(h), tail: toNodes(t, f, rest))
-fun countNodes(ns: Nodes) -> Int = match ns
+fun countNodes(ns: List[SceneNode]) -> Int = match ns
-  End => 0
+  Nil => 0
-  More(_, t) => 1 + countNodes(t)
+  Cons(_, t) => 1 + countNodes(t)
 # A sprite of the sheet inside its group, spinning about its centre.
 struct Dancer(gi: Int, id: Int, x: Float, y: Float, rotation: Float, srcX: Float)
@@ -67,7 +67,7 @@ struct Drifter(id: Int, x: Float, y: Float, w: Float, h: Float, dx: Float, dy: F
 # Shows "n <count>" and counts up each frame.
 struct Counter(id: Int, x: Float, y: Float, n: Int)
-record State(sheet: Int, white: Int, spinners: Link[Spinner], dancers: Link[Dancer], drifters: Link[Drifter], counters: Link[Counter])
+record State(sheet: Int, white: Int, spinners: List[Spinner], dancers: List[Dancer], drifters: List[Drifter], counters: List[Counter])
 fun hue(i: Int) -> Color =
   Color(r: Float(i % 7) / 7.0, g: Float(i % 5) / 5.0, b: 0.4 + Float(i % 3) / 5.0, a: 0.8)
@@ -83,7 +83,7 @@ fun newSpinner(gi: Int) -> Spinner =
   Spinner(id: 100 + gi, x: Float(gi % 10 * 160), y: Float(gi / 10 * 180), rotation: 0.0)
 # All dancers, group after group, built by recursion over the spinner index.
-fun allDancers(gi: Int) -> Link[Dancer] =
+fun allDancers(gi: Int) -> List[Dancer] =
   if gi >= Counts.Groups then Nil else appendLink(rangeLink(0, Counts.Sprites / Counts.Groups, |j| newDancer(gi, j)), allDancers(gi + 1))
 fun newState(sheet: Int, white: Int) -> State =
@@ -124,29 +124,29 @@ fun step(s: State, dt: Float) -> State =
 fun dancerView(sheet: Int, d: Dancer) -> SceneNode =
   Group(
     transform: Compose(first: Translate(dx: d.x + 8.0, dy: d.y + 8.0), then: Compose(first: Rotate(radians: d.rotation), then: Translate(dx: 0.0 - 8.0, dy: 0.0 - 8.0))),
-    children: More(head: Sprite(
+    children: Cons(head: Sprite(
       tex: sheet, x: 0.0, y: 0.0, w: 16.0, h: 16.0, srcX: d.srcX, srcY: 0.0, srcW: 16.0, srcH: 16.0,
-      tint: Color.White), tail: End))
+      tint: Color.White), tail: Nil))
 # The leading dancers of `ds` that belong to group `gi`, as nodes.
-fun groupNodes(sheet: Int, ds: Link[Dancer], gi: Int) -> Nodes = match ds
+fun groupNodes(sheet: Int, ds: List[Dancer], gi: Int) -> List[SceneNode] = match ds
-  Nil => End
+  Nil => Nil
-  Cons(h, t) => if h.gi == gi then More(head: dancerView(sheet, h), tail: groupNodes(sheet, t, gi)) else End
+  Cons(h, t) => if h.gi == gi then Cons(head: dancerView(sheet, h), tail: groupNodes(sheet, t, gi)) else Nil
 # `ds` without its leading dancers of group `gi`.
-fun dropGroup(ds: Link[Dancer], gi: Int) -> Link[Dancer] = match ds
+fun dropGroup(ds: List[Dancer], gi: Int) -> List[Dancer] = match ds
   Nil => Nil
   Cons(h, t) => if h.gi == gi then dropGroup(t, gi) else ds
-fun spinnerView(sheet: Int, p: Spinner, ds: Link[Dancer]) -> SceneNode =
+fun spinnerView(sheet: Int, p: Spinner, ds: List[Dancer]) -> SceneNode =
   Group(
     transform: Compose(first: Translate(dx: p.x + 75.0, dy: p.y + 85.0), then: Compose(first: Rotate(radians: p.rotation), then: Translate(dx: 0.0 - 75.0, dy: 0.0 - 85.0))),
     children: groupNodes(sheet, ds, p.id - 100))
 # Spinner groups in order, each taking its dancers from the front of the one list.
-fun spinnerNodes(sheet: Int, ps: Link[Spinner], ds: Link[Dancer], rest: Nodes) -> Nodes = match ps
+fun spinnerNodes(sheet: Int, ps: List[Spinner], ds: List[Dancer], rest: List[SceneNode]) -> List[SceneNode] = match ps
   Nil => rest
-  Cons(p, t) => More(head: spinnerView(sheet, p, ds), tail: spinnerNodes(sheet, t, dropGroup(ds, p.id - 100), rest))
+  Cons(p, t) => Cons(head: spinnerView(sheet, p, ds), tail: spinnerNodes(sheet, t, dropGroup(ds, p.id - 100), rest))
 fun drifterView(white: Int, d: Drifter) -> SceneNode =
   Sprite(
@@ -157,7 +157,7 @@ fun counterView(c: Counter) -> SceneNode =
   Text(text: "n {c.n}", x: c.x, y: c.y, size: 14.0, color: Color.White)
 fun view(s: State) -> SceneNode =
-  texts := toNodes(s.counters, |c| counterView(c), End)
+  texts := toNodes(s.counters, |c| counterView(c), Nil)
   drifts := toNodes(s.drifters, |d| drifterView(s.white, d), texts)
   Group(transform: Scale(sx: 0.8, sy: 0.8), children: spinnerNodes(s.sheet, s.spinners, s.dancers, drifts))
@@ -199,4 +199,4 @@ test "view has one node per actor"
 test "dancers in one list 5000"
   s := newState(0, 0)
-  assert countNodes(toNodes(s.dancers, |d| dancerView(0, d), End)) == 5000
+  assert countNodes(toNodes(s.dancers, |d| dancerView(0, d), Nil)) == 5000

plum-game/web-test/fixtures/stress_world.plum CHANGED Viewed

@@ -8,7 +8,7 @@ import std/Str
 import std/Int
 import std/Float
 import std/Math
-import std/List
+import std/Slice
 import std/game/Vec2
 import std/game/Color
 import std/game/Game

plum-lsp/src/main.rs CHANGED Viewed

@@ -942,14 +942,14 @@ mod tests {
         }
     }
-    /// `xs.` on a List offers List's own methods AND the Seq methods reached
+    /// `xs.` on a Slice offers Slice's own methods AND the Seq methods reached
     /// through the iterable fallback.
     #[test]
-    fn memberCompletionOnListIncludesSeqMethods() {
+    fn memberCompletionOnSliceIncludesSeqMethods() {
         let dir = std::env::temp_dir().join(format!("plum-lsp-test-{}", std::process::id()));
         std::fs::create_dir_all(&dir).unwrap();
         let path = dir.join("t.plum");
-        let text = "module t\nimport std/Int\nimport std/Float\nimport std/List\nimport std/Seq\n\nfun main() =\n  xs := List(1, 2, 3)\n  xs.zzzzzz\n";
+        let text = "module t\nimport std/Int\nimport std/Float\nimport std/Slice\nimport std/Seq\n\nfun main() =\n  xs := Slice(1, 2, 3)\n  xs.zzzzzz\n";
         std::fs::write(&path, text).unwrap();
         let items = memberCompletionFor(&path, &repoRoot(), text, 8, "xs");
         let labels: Vec<&str> = items.iter().map(|i| i.label.as_str()).collect();
@@ -989,7 +989,7 @@ mod tests {
         let dir = std::env::temp_dir().join(format!("plum-lsp-fsm-{}", std::process::id()));
         std::fs::create_dir_all(&dir).unwrap();
         let path = dir.join("t.plum");
-        let text = "module t\nimport std/Int\nimport std/Float\nimport std/Str\nimport std/List\nimport std/Map\n\nfun main() =\n  f := 1.5\n  f.zzzzzz\n  s := \"x\"\n  s.zzzzzz\n  m := Map[Str, Int]()\n  m.zzzzzz\n";
+        let text = "module t\nimport std/Int\nimport std/Float\nimport std/Str\nimport std/Slice\nimport std/Map\n\nfun main() =\n  f := 1.5\n  f.zzzzzz\n  s := \"x\"\n  s.zzzzzz\n  m := Map[Str, Int]()\n  m.zzzzzz\n";
         std::fs::write(&path, text).unwrap();
         let cases: [(usize, &str, &[&str]); 3] = [
             (9, "f", &["sqrt", "toStr"]),

plum-std/Array.plum CHANGED Viewed

@@ -23,7 +23,7 @@ import std/Byte
 # stay arrays of references.) `init`/`get`/`set`/`length`/
 # `push`/`resize` are compiler intrinsics (see `compileIntrinsicFnBody`) —
 # there's no way to express raw array allocation/indexing in Plum source itself.
-# `List[T]` is built on this.
+# `Slice[T]` is built on this.
 #
 # `init()` is deliberately zero-arg (no `Array[T](n)` constructor exists) —
 # `class_call`'s grammar (`Type[Generics](...)`) only ever accepts `name:
@@ -67,7 +67,7 @@ primitive Array[T] =
     todo
   # Returns a NEW array of length `n` holding `self`'s first `min(length, n)`
-  # elements (the remaining slots null-shaped, like `init`/`push`). `List`
+  # elements (the remaining slots null-shaped, like `init`/`push`). `Slice`
   # grows by doubling through this.
   fun resize(self, n: Int) -> Array[T] =
     todo

plum-std/Deque.plum CHANGED Viewed

@@ -1,6 +1,6 @@
 module std
 import std/Array
-import std/List
+import std/Slice
 import std/Int
 import std/Float

plum-std/Heap.plum CHANGED Viewed

@@ -1,6 +1,6 @@
 module std
 import std/Array
-import std/List
+import std/Slice
 import std/Int
 import std/Float
@@ -11,7 +11,7 @@ import std/Float
 # comparison, so keep it cheap and don't mutate an element's key while it is in
 # the heap. `push`/`pop` are O(log n); `peek`/`length` are O(1). Equal keys pop in
 # no guaranteed order.
-record Heap[T](items: List[T], key: fn(T) -> Float) =
+record Heap[T](items: Slice[T], key: fn(T) -> Float) =
   fun length(self) -> Int =
     return self.items.length()
@@ -77,7 +77,7 @@ record Heap[T](items: List[T], key: fn(T) -> Float) =
     top
 test "heap_pop_order: 1000 pseudo-random keys pop in ascending order"
-  h := Heap[Int](items: List[Int](), key: |x| Float(x))
+  h := Heap[Int](items: Slice[Int](), key: |x| Float(x))
   x := 12345
   i := 0
   while i < 1000
@@ -96,7 +96,7 @@ test "heap_pop_order: 1000 pseudo-random keys pop in ascending order"
   assert {h.pop() catch -1} == -1
 test "peek shows the minimum and Float keys order records"
-  h := Heap[Float](items: List[Float](), key: |x| 0.0 - x)
+  h := Heap[Float](items: Slice[Float](), key: |x| 0.0 - x)
   h.push(1.5)
   h.push(9.5)
   h.push(4.0)

plum-std/Http.plum CHANGED Viewed

@@ -2,7 +2,7 @@ module std
 import std/Buffer
 import std/Json
-import std/List
+import std/Slice
 import std/Map
 import std/Str
 import std/Int

plum-std/Json.plum CHANGED Viewed

@@ -1,6 +1,6 @@
 module std
-import std/List
+import std/Slice
 import std/Map
 import std/Int
 import std/Float
@@ -8,9 +8,9 @@ import std/Str
 import std/Buffer
 # Placement rule for built-in `toJson` / `fromJson`: they live HERE, in this
-# file, as extension blocks at the bottom (`primitive Int =`, `primitive List[T] =`),
+# file, as extension blocks at the bottom (`primitive Int =`, `primitive Slice[T] =`),
 # holding only `fun`s. The loader merges them into the type's methods, so they
-# exist only in programs that import std/Json, and Int/Str/List/Map never
+# exist only in programs that import std/Json, and Int/Str/Slice/Map never
 # import Json (no cycle, no Pair/Bool drag-in). Std-only; a duplicate method
 # name is a collision error. `Json.encode` / `Json.decode` stay duck-typed and
 # call `x.toJson()` / `T.fromJson(j)` per instantiation.
@@ -20,15 +20,15 @@ error JsonError = InvalidJson | WrongJsonType | MissingField
 # A parsed JSON value. Numbers are always stored as `Float` (JSON doesn't
-# distinguish integers from floats the way Plum does), and `List[Json]`/
+# distinguish integers from floats the way Plum does), and `Slice[Json]`/
-# `Map[Str, Json]` nest `Json` itself — the same self-referential shape `List[T]`
+# `Map[Str, Json]` nest `Json` itself — the same self-referential shape `Slice[T]`
 # already uses internally for `Node[T].next: Link[Node[T]]`.
 enum Json =
   | JsonNull
   | Bool
   | Float
   | Str
-  | List[Json]
+  | Slice[Json]
   | Map[Str, Json]
   # Parses `s` as a single JSON document, requiring the whole string (aside
@@ -56,7 +56,7 @@ enum Json =
       Bool => if self then "true" else "false"
       Float => self.toStr()
       Str => "\"" + escapeJsonStr(self) + "\""
-      List => "[" + self.join(",") + "]"
+      Slice => "[" + self.join(",") + "]"
       Map => "{{" + jsonMapToStr(self) + "}}"
   # ---- encode / decode API ----
@@ -93,7 +93,7 @@ enum Json =
     return m
   fun array(items: ...Json) -> Json =
-    out := List[Json]()
+    out := Slice[Json]()
     for x := range items
       out.push(x)
     return out
@@ -122,9 +122,9 @@ enum Json =
       Str => self
       _ => error.WrongJsonType
-  fun asList(self) -> error{WrongJsonType}!List[Json] =
+  fun asList(self) -> error{WrongJsonType}!Slice[Json] =
     match self
-      List => self
+      Slice => self
       _ => error.WrongJsonType
   fun asMap(self) -> error{WrongJsonType}!Map[Str, Json] =
@@ -132,7 +132,7 @@ enum Json =
       Map => self
       _ => error.WrongJsonType
-  # `Map` has no built-in `toStr`/`join` (unlike `List`, which uses `join` for
+  # `Map` has no built-in `toStr`/`join` (unlike `Slice`, which uses `join` for
   # `Json.toStr`'s `JsonList` case above) — a static taking the
   # `Buffer` as a captured-by-reference parameter instead of a closure sidesteps
   # `libs/std/list.plum`'s `join` note on closures: reassigning a CAPTURED
@@ -411,7 +411,7 @@ record JsonParser(src: Str, pos: Int, text: Str) =
   fun parseArray(self) -> error{InvalidJson}!Json =
     self.advance()
     self.skipSpace()
-    items := List[Json]()
+    items := Slice[Json]()
     if self.peek() == 93
       self.advance()
       return items
@@ -512,18 +512,18 @@ primitive Str =
   fun fromJson(j: Json) -> JsonError!Str = j.asStr()
-primitive List[T] =
+primitive Slice[T] =
   # A JSON array of the elements' own `toJson()`.
   fun toJson(self) -> Json =
-    out := List[Json]()
+    out := Slice[Json]()
     for x := range self
       out.push(x.toJson())
     return out
   # Decodes each element with `T.fromJson`.
-  fun fromJson(j: Json) -> JsonError!List[T] =
+  fun fromJson(j: Json) -> JsonError!Slice[T] =
     items := try j.asList()
-    out := List[T]()
+    out := Slice[T]()
     for x := range items
       out.push(try T.fromJson(x))
     return out
@@ -545,15 +545,15 @@ primitive Map[K, V] =
 fun jsonTestDecodeInt(s: Str) -> JsonError!Int = Json.decode(s)
-fun jsonTestDecodeNested(s: Str) -> JsonError!List[List[Int]] = Json.decode(s)
+fun jsonTestDecodeNested(s: Str) -> JsonError!Slice[Slice[Int]] = Json.decode(s)
 fun jsonTestDecodeMap(s: Str) -> JsonError!Map[Str, Int] = Json.decode(s)
 fun jsonTestDecodeStr(s: Str) -> JsonError!Str = Json.decode(s)
 # Fixture for the round-trip tests: a hand-written record codec (also a
-# worked example of the pattern), including a List of itself.
+# worked example of the pattern), including a Slice of itself.
-record JsonTestHouse(name: Str, rooms: Int, kids: List[JsonTestHouse]) =
+record JsonTestHouse(name: Str, rooms: Int, kids: Slice[JsonTestHouse]) =
   fun toJson(self) -> Json =
     Json.object(Pair("name", self.name.toJson()), Pair("rooms", self.rooms.toJson()), Pair("kids", self.kids.toJson()))
@@ -563,7 +563,7 @@ record JsonTestHouse(name: Str, rooms: Int, kids: List[JsonTestHouse]) =
     kids := try jsonTestKidsOf(try j.field("kids"))
     return JsonTestHouse(name: name, rooms: rooms, kids: kids)
-fun jsonTestKidsOf(j: Json) -> JsonError!List[JsonTestHouse] = j.into()
+fun jsonTestKidsOf(j: Json) -> JsonError!Slice[JsonTestHouse] = j.into()
 fun jsonTestHouseError(s: Str) -> Str =
   jsonTestDecodeHouse(s) catch e
@@ -684,11 +684,11 @@ test "escapes a 50000 character string of quotes and newlines"
 test "extension: Int.toJson encodes a number"
   assert 42.toJson().toStr() == "42.0"
-test "extension: List.toJson encodes an array"
+test "extension: Slice.toJson encodes an array"
-  assert List(1, 2, 3).toJson().toStr() == "[1.0,2.0,3.0]"
+  assert Slice(1, 2, 3).toJson().toStr() == "[1.0,2.0,3.0]"
-test "extension: nested List.toJson recurses through T.toJson"
+test "extension: nested Slice.toJson recurses through T.toJson"
-  assert List(List(1), List(2, 3)).toJson().toStr() == "[[1.0],[2.0,3.0]]"
+  assert Slice(Slice(1), Slice(2, 3)).toJson().toStr() == "[[1.0],[2.0,3.0]]"
 test "api: field missing, wrong container, optField"
   o := Json.fromStr("{{\"a\":1}}")!
@@ -715,7 +715,7 @@ test "nested_list_of_lists round-trips"
   assert v.length() == 3
   assert v.get(0)!.get(1)! == 2
   assert Json.encode(v) == "[[1.0,2.0],[3.0],[]]"
-  assert {jsonTestDecodeNested("[[1,\"x\"]]") catch List[List[Int]]()}.length() == 0
+  assert {jsonTestDecodeNested("[[1,\"x\"]]") catch Slice[Slice[Int]]()}.length() == 0
 test "map_non_object_rejected"
   assert {jsonTestDecodeMap("[]") catch Map[Str, Int]()}.length() == 0
@@ -726,8 +726,8 @@ test "str_unicode_roundtrip"
   assert jsonTestDecodeStr(Json.encode(s))! == s
 test "record round-trips including a list of itself"
-  kid := JsonTestHouse(name: "k\"1", rooms: 2, kids: List[JsonTestHouse]())
+  kid := JsonTestHouse(name: "k\"1", rooms: 2, kids: Slice[JsonTestHouse]())
-  kids := List[JsonTestHouse]()
+  kids := Slice[JsonTestHouse]()
   kids.push(kid)
   h := JsonTestHouse(name: "main\n", rooms: 5, kids: kids)
   text := Json.encode(h)
@@ -739,9 +739,9 @@ test "record round-trips including a list of itself"
   assert Json.encode(back) == text
 test "field_missing and decode_invalid"
-  assert {jsonTestDecodeHouse("{{\"name\":\"x\"}}") catch JsonTestHouse(name: "E", rooms: 0, kids: List[JsonTestHouse]())}.name == "E"
+  assert {jsonTestDecodeHouse("{{\"name\":\"x\"}}") catch JsonTestHouse(name: "E", rooms: 0, kids: Slice[JsonTestHouse]())}.name == "E"
-  assert {jsonTestDecodeHouse("{{oops") catch JsonTestHouse(name: "E", rooms: 0, kids: List[JsonTestHouse]())}.name == "E"
+  assert {jsonTestDecodeHouse("{{oops") catch JsonTestHouse(name: "E", rooms: 0, kids: Slice[JsonTestHouse]())}.name == "E"
-  assert {jsonTestDecodeHouse("[1]") catch JsonTestHouse(name: "E", rooms: 0, kids: List[JsonTestHouse]())}.name == "E"
+  assert {jsonTestDecodeHouse("[1]") catch JsonTestHouse(name: "E", rooms: 0, kids: Slice[JsonTestHouse]())}.name == "E"
 test "decodeWith uses an explicit decoder"
   h := Json.decodeWith("{{\"name\":\"w\",\"rooms\":1,\"kids\":[]}}", |j| JsonTestHouse.fromJson(j))!

plum-std/List.plum ADDED Viewed

@@ -0,0 +1,136 @@
+module std
+import std/Array
+import std/Buffer
+import std/Int
+import std/Slice
+import std/Str
+# A cons list: `Nil` or a head in front of another list. Operations are written
+# so they run in constant stack: self tail calls become loops, a constructor
+# wrapped single self call (`map`) is rewritten to a loop (TRMC), and `filter`
+# builds through an accumulator that is reversed at the end.
+enum List[T] =
+  | Nil
+  | Cons(head: T, tail: List[T])
+  # `List(1, 2, 3)`: built back to front so each cell is allocated once.
+  fun init(values: ...T) -> List[T] =
+    out: List[T] := Nil
+    i := values.length() - 1
+    while i >= 0
+      out = Cons(head: values.at(i), tail: out)
+      i = i - 1
+    return out
+  fun isEmpty(self) -> Bool = match self
+    Nil => true
+    Cons(_, _) => false
+  fun lengthFrom(self, acc: Int) -> Int = match self
+    Nil => acc
+    Cons(_, t) => t.lengthFrom(acc + 1)
+  fun length(self) -> Int = self.lengthFrom(0)
+  # The element at index i, or null when out of range.
+  fun get(self, i: Int) -> T? = match self
+    Nil => null
+    Cons(h, t) => if i < 0 then null else if i == 0 then h else t.get(i - 1)
+  # The element at index i (the `for x := range xs` protocol, O(i) per call, so a
+  # plain `for` is quadratic: prefer `for x := range xs.items()`). Crashes out of range.
+  fun at(self, i: Int) -> T = self.get(i) ?: crash "List.at out of range"
+  fun map(self, f: fn(T) -> B) -> List[B] = mapCells(self, f)
+  # Left fold: `f(f(f(acc, x0), x1), x2)`.
+  fun fold(self, acc: A, f: fn(A, T) -> A) -> A = match self
+    Nil => acc
+    Cons(h, t) => t.fold(f(acc, h), f)
+  # Pushes the elements of `self` onto `acc` one by one (so they come out reversed).
+  fun revOnto(self, acc: List[T]) -> List[T] = match self
+    Nil => acc
+    Cons(h, t) => t.revOnto(Cons(head: h, tail: acc))
+  fun reverse(self) -> List[T] =
+    nil: List[T] := Nil
+    self.revOnto(nil)
+  fun keepRev(self, keep: fn(T) -> Bool, acc: List[T]) -> List[T] = match self
+    Nil => acc
+    Cons(h, t) => t.keepRev(keep, if keep(h) then Cons(head: h, tail: acc) else acc)
+  fun filter(self, keep: fn(T) -> Bool) -> List[T] =
+    nil: List[T] := Nil
+    self.keepRev(keep, nil).reverse()
+  # `self` followed by `ys`. Only `self` is rebuilt; `ys` is shared.
+  fun append(self, ys: List[T]) -> List[T] =
+    self.reverse().revOnto(ys)
+  # A `for` source: `for x := range xs`.
+  fun* items(self) *T =
+    cur := self
+    while true
+      if Cons(h, t) := cur
+        cur = t
+        yield h
+      else
+        break
+  # The elements of `xs` as a cons list, in order.
+  fun fromSlice(xs: Slice[T]) -> List[T] =
+    out: List[T] := Nil
+    i := xs.length() - 1
+    while i >= 0
+      out = Cons(head: xs.at(i), tail: out)
+      i = i - 1
+    return out
+  fun toSlice(self) -> Slice[T] =
+    out := Slice()
+    for x := range self.items()
+      out.push(x)
+    return out
+  fun toArray(self) -> Array[T] =
+    out := Array[T]()
+    for x := range self.items()
+      out = out.push(x)
+    return out
+  fun toStr(self) -> Str =
+    res := Buffer()
+    res.write("[")
+    first := true
+    for x := range self.items()
+      if !first
+        res.write(",")
+      first = false
+      res.write(x.toStr())
+    res.write("]")
+    return res.toStr()
+  # Elementwise comparison via `==`.
+  fun equals(self, other: List[T]) -> Bool =
+    a := self
+    b := other
+    while true
+      if Cons(h, t) := a
+        if Cons(h2, t2) := b
+          if h != h2
+            return false
+          a = t
+          b = t2
+        else
+          return false
+      else
+        return b.isEmpty()
+    return true
+# `map`'s loop: a constructor wrapped self call, rewritten to a loop (TRMC).
+fun mapCells(xs: List[A], f: fn(A) -> B) -> List[B] = match xs
+  Nil => Nil
+  Cons(h, t) => Cons(head: f(h), tail: mapCells(t, f))

plum-std/Map.plum CHANGED Viewed

@@ -1,5 +1,5 @@
 module std
-import std/List
+import std/Slice
 import std/Array
 import std/Int
 import std/Float

plum-std/Os.plum CHANGED Viewed

@@ -1,5 +1,5 @@
 module std
-import std/List
+import std/Slice
 import std/Str
 import std/Uuid
 import std/Int
@@ -164,14 +164,14 @@ primitive Os =
     todo
   # The names of `path`'s directory entries (not full paths).
-  fun readdir(path: Str) -> error{NoSuchPath}!List[Str] =
+  fun readdir(path: Str) -> error{NoSuchPath}!Slice[Str] =
     if !exists(path)
       return error.NoSuchPath
     # skipping empty names handles both a genuinely empty directory (whose
     # joined `""` would otherwise split into one bogus `""` entry) and
     # `rawReadDir`'s "unreadable" fallback (already ruled out by the `exists`
     # check above) the same way — no directory entry is ever named `""`.
-    names := List[Str]()
+    names := Slice[Str]()
     for n := range rawReadDir(path).split("\n", 0)
       if n != ""
         names.push(n)

plum-std/Seq.plum CHANGED Viewed

@@ -2,18 +2,18 @@ module std
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 # Sequences. `xs.filter()` in a `for` source reads like a method chain but is
 # expanded at the use site into ONE loop: no closure, no `call_indirect`, no
-# intermediate List. See `plum-core/src/forms.rs` for the precise rules.
+# intermediate Slice. See `plum-core/src/forms.rs` for the precise rules.
 #
 #   * `Seq[T]` is a compiler primitive; `*T` is sugar for it. A Seq never exists
 #     at runtime: it can't be stored, returned or captured, only flow into a
 #     `for` source or the next method call.
 #   * The methods below are declared with `extend Seq[T]`. `xs.m()` where the type
 #     of `xs` has no `m` of its own and is iterable (`length()`/`at(i)`) resolves
-#     to `Seq.m`, so `units.filter()` works on a List, an Array, a Deque, ...
+#     to `Seq.m`, so `units.filter()` works on a Slice, an Array, a Deque, ...
 #   * ADAPTERS reshape a sequence and have no result (`take`, `skip`, `stepBy`,
 #     `zip`, `reversed`, `chunks`): they may appear anywhere in a chain.
 #   * TERMINALS declare a result `-> R` and take the `for` body (`filter`, `map`,
@@ -26,7 +26,7 @@ import std/List
 #     `return` returns from the enclosing fn.
 #   * `self` of an adapter or terminal that only uses it as a `for` source is the
 #     whole upstream chain, which is how a chain fuses. `zip`, `reversed` and
-#     `chunks` need random access, so their receiver must be a List.
+#     `chunks` need random access, so their receiver must be a Slice.
 primitive Seq[T] =
   # ---- adapters ---------------------------------------------------------------
@@ -59,7 +59,7 @@ primitive Seq[T] =
         yield x
   # `for a, b := range xs.zip(ys)`: pairs up to the shorter length.
-  fun* zip(self, ys: List[B]) *(T, B) =
+  fun* zip(self, ys: Slice[B]) *(T, B) =
     n := self.length()
     m := ys.length()
     k := if n < m then n else m
@@ -73,7 +73,7 @@ primitive Seq[T] =
       yield self.at(n - 1 - i)
   # Consecutive pieces of `size` elements (the last may be shorter).
-  fun* chunks(self, size: Int) *List[T] =
+  fun* chunks(self, size: Int) *Slice[T] =
     n := self.length()
     start := 0
     while start < n
@@ -85,16 +85,16 @@ primitive Seq[T] =
   # ---- terminals --------------------------------------------------------------
   # The elements for which the body is true.
-  fun* filter(self) *T -> List[T] =
+  fun* filter(self) *T -> Slice[T] =
-    out := List()
+    out := Slice()
     for x := range self
       if yield x
         out.push(x)
     out
   # The body's value for every element.
-  fun* map(self) *T -> List[U] =
+  fun* map(self) *T -> Slice[U] =
-    out := List()
+    out := Slice()
     for x := range self
       v := yield x
       out.push(v)
@@ -102,7 +102,7 @@ primitive Seq[T] =
   # The first element for which the body is true, or null. Stops there.
   fun* find(self) *T -> T? =
-    hit := List()
+    hit := Slice()
     for x := range self
       if yield x
         hit.push(x)
@@ -149,8 +149,8 @@ primitive Seq[T] =
       yield x
   # The first `n` elements for which the body is true. Stops there.
-  fun* firstN(self, n: Int) *T -> List[T] =
+  fun* firstN(self, n: Int) *T -> Slice[T] =
-    out := List()
+    out := Slice()
     if n > 0
       for x := range self
         if yield x
@@ -159,9 +159,9 @@ primitive Seq[T] =
             break
     out
-  # `xs.take(3).toList()`: the elements as a List (no body).
+  # `xs.take(3).toList()`: the elements as a Slice (no body).
-  fun* toList(self) *T -> List[T] =
+  fun* toList(self) *T -> Slice[T] =
-    out := List()
+    out := Slice()
     for x := range self
       yield x
       out.push(x)

plum-std/Set.plum CHANGED Viewed

@@ -1,6 +1,6 @@
 module std
 import std/Map
-import std/List
+import std/Slice
 import std/Int
 import std/Float
@@ -32,8 +32,8 @@ record Set[T](map: Map[T, Bool]) =
     self.map.clear()
   # Every member, in insertion order.
-  fun toList(self) -> List[T] =
+  fun toList(self) -> Slice[T] =
-    result := List[T]()
+    result := Slice[T]()
     for k := range self.map.keys()
       result.push(k)
     return result

plum-std/Slice.plum CHANGED Viewed

@@ -9,22 +9,22 @@ import std/Str
 # A growable list over a backing `Array[T]`: element `i` is `data[start + i]`,
 # `size` slots are in use and `cap` slots (from `start`) may be written. Capacity
 # doubles when `push` runs out of room, so `push` is O(1) amortized and
-# `get`/`set` are O(1). `slice(i, j)` returns a VIEW: a new `List` over the same
+# `get`/`set` are O(1). `slice(i, j)` returns a VIEW: a new `Slice` over the same
 # array (no copy) whose `cap` equals its `size`, so `set` on a view writes the
 # parent's storage while a `push` on a view moves it to a fresh array and never
 # overwrites the parent. In-place reordering (`removeAt`, `reverse`) of a list
 # is visible through its views; `sublist` copies. The core operations (`init`, `length`, `get`, `set`,
 # `push`, `pop`, `clear`) sit directly on the `Array` intrinsics; everything
 # else (`map`, `retain`, `reduce`, `chunk`, ...) is ordinary Plum on top of them.
-record List[T](data: Array[T], start: Int, size: Int, cap: Int) =
+record Slice[T](data: Array[T], start: Int, size: Int, cap: Int) =
-  # `List[T](1, 2, 3)` (or, for an empty list, `List[T]()` — explicit
+  # `Slice[T](1, 2, 3)` (or, for an empty list, `Slice[T]()` — explicit
   # generics required either way, since nothing else in a call this shape
   # pins down `T`) constructs a list via this variadic `init` — see
   # `plum-checker`/`plum-wasm-codegen`'s `ClassCall`/`FnCall` handling, which
-  # desugars both call shapes to `List.init(...)`.
+  # desugars both call shapes to `Slice.init(...)`.
-  fun init(values: ...T) -> List[T] =
+  fun init(values: ...T) -> Slice[T] =
-    l := List(data: Array[T](), start: 0, size: 0, cap: 0)
+    l := Slice(data: Array[T](), start: 0, size: 0, cap: 0)
     for v := range values
       l.push(v)
     return l
@@ -48,7 +48,7 @@ record List[T](data: Array[T], start: Int, size: Int, cap: Int) =
     self.data.get(self.start + i)
   # Rewrites every slot with `f(old)` and returns the same list (no new list).
-  fun mapInPlace(own self, f: fn(T) -> T) -> List[T] =
+  fun mapInPlace(own self, f: fn(T) -> T) -> Slice[T] =
     i := 0
     while i < self.size
       self.data.set(self.start + i, f(self.data.get(self.start + i)))
@@ -71,7 +71,7 @@ record List[T](data: Array[T], start: Int, size: Int, cap: Int) =
   # Elementwise comparison via `==` — see the caveat on `expectEq` in
   # `libs/std/testing.plum` for what that means when `T` is a class/enum
   # without its own `equals` (reference identity, not structural equality).
-  fun equals(self, other: List[T]) -> Bool =
+  fun equals(self, other: Slice[T]) -> Bool =
     if self.length() != other.length()
       return false
     i := 0
@@ -106,10 +106,10 @@ record List[T](data: Array[T], start: Int, size: Int, cap: Int) =
   # A view of the elements at `[i, j)`, clamped into range: shares this list's
   # storage (no copy). `set` on the view changes this list; `push` on the view
   # copies it out first.
-  fun slice(self, i: Int, j: Int) -> List[T] =
+  fun slice(self, i: Int, j: Int) -> Slice[T] =
     s := if i < 0 then 0 else if i > self.size then self.size else i
     e := if j > self.size then self.size else if j < s then s else j
-    return List(data: self.data, start: self.start + s, size: e - s, cap: e - s)
+    return Slice(data: self.data, start: self.start + s, size: e - s, cap: e - s)
   # adds the specified elements to the end of the list
   fun add(self, values: ...T) =
@@ -147,7 +147,7 @@ record List[T](data: Array[T], start: Int, size: Int, cap: Int) =
     self.size = 0
   # reverses the list in place, returning it.
-  fun reverse(self) -> List[T] =
+  fun reverse(self) -> Slice[T] =
     i := 0
     j := self.size - 1
     while i < j
@@ -160,7 +160,7 @@ record List[T](data: Array[T], start: Int, size: Int, cap: Int) =
   # Returns a NEW list with `self`'s elements sorted, using `before(a, b)` as
   # the "does a belong before b" comparator. Insertion sort (O(n^2)).
-  fun sort(self, before: fn(T, T) -> Bool) -> List[T] =
+  fun sort(self, before: fn(T, T) -> Bool) -> Slice[T] =
     result := self.sublist(0, self.size)
     i := 1
     while i < result.size
@@ -213,8 +213,8 @@ record List[T](data: Array[T], start: Int, size: Int, cap: Int) =
   # Returns a new list of the elements at index `[start, end)`, clamped into
   # range (a `start`/`end` outside `[0, length]` is clamped, not an error).
-  fun sublist(self, start: Int, end: Int) -> List[T] =
+  fun sublist(self, start: Int, end: Int) -> Slice[T] =
-    result := List[T]()
+    result := Slice[T]()
     s := if start < 0 then 0 else start
     e := if end > self.size then self.size else end
     i := s
@@ -224,7 +224,7 @@ record List[T](data: Array[T], start: Int, size: Int, cap: Int) =
     return result
   # Every element AFTER the first `n` (a copy; `xs.skip(n)` in a `for` is the lazy form).
-  fun drop(self, n: Int) -> List[T] =
+  fun drop(self, n: Int) -> Slice[T] =
     return self.sublist(n, self.size)
   # Returns one uniformly random element, or fails with `ListWasEmpty` if `self` is empty.
@@ -234,7 +234,7 @@ record List[T](data: Array[T], start: Int, size: Int, cap: Int) =
     return self.data.get(self.start + Random.intBelow(self.size))
   # Returns a new list with `self`'s elements in random order (Fisher-Yates).
-  fun shuffle(self) -> List[T] =
+  fun shuffle(self) -> Slice[T] =
     result := self.sublist(0, self.size)
     i := result.size - 1
     while i > 0
@@ -246,8 +246,8 @@ record List[T](data: Array[T], start: Int, size: Int, cap: Int) =
     return result
   # Splits into consecutive sublists of at most `size` elements each.
-  fun chunk(self, size: Int) -> List[List[T]] =
+  fun chunk(self, size: Int) -> Slice[Slice[T]] =
-    result := List[List[T]]()
+    result := Slice[Slice[T]]()
     if size <= 0
       return result
     i := 0
@@ -257,7 +257,7 @@ record List[T](data: Array[T], start: Int, size: Int, cap: Int) =
       i = i + size
     return result
-  # Grouping by an arbitrary key type would need `Map[K, List[T]]`, but
+  # Grouping by an arbitrary key type would need `Map[K, Slice[T]]`, but
   # `Map.plum` depends on this file. Not implemented.
   fun groupBy(self) =
     todo
@@ -278,7 +278,7 @@ record List[T](data: Array[T], start: Int, size: Int, cap: Int) =
 # ---- regression tests ----
 test "list add set remove at remove clear reverse all work correctly"
-  l := List(1, 2, 3, 4, 5)
+  l := Slice(1, 2, 3, 4, 5)
   assert l.length() == 5
   assert l.get(0)! == 1
   assert l.get(4)! == 5
@@ -295,7 +295,7 @@ test "list add set remove at remove clear reverse all work correctly"
   assert l.length() == 0
 test "removing every node in a loop leaves an empty correctly functioning list"
-  l := List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+  l := Slice(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
   i := 0
   while i < 10
     l.removeAt(0)
@@ -305,44 +305,44 @@ test "removing every node in a loop leaves an empty correctly functioning list"
   l.add(42)
   assert l.get(0)! == 42
-test "List[Int]() with no args runs init() and produces a working empty list"
+test "Slice[Int]() with no args runs init() and produces a working empty list"
-  l := List[Int]()
+  l := Slice[Int]()
   assert l.length() == 0
   l.add(7)
   assert l.length() == 1
   assert l.get(0)! == 7
-test "List(values) with positional args runs init(values) directly, infers T from args"
+test "Slice(values) with positional args runs init(values) directly, infers T from args"
-  l := List(10, 20, 30)
+  l := Slice(10, 20, 30)
   assert l.length() == 3
   assert l.get(0)! == 10
   assert l.get(2)! == 30
 test "list equals compares elementwise"
-  a = List(1, 2, 3)
+  a = Slice(1, 2, 3)
-  b = List(1, 2, 3)
+  b = Slice(1, 2, 3)
-  c = List(1, 2)
+  c = Slice(1, 2)
   assert a.equals(b)
   assert !a.equals(c)
 test "list sort orders elements correctly"
-  l = List(3, 1, 4, 1, 5)
+  l = Slice(3, 1, 4, 1, 5)
   sorted = l.sort(|a, b| a < b)
   assert {sorted.get(0) catch -1000} == 1
   assert {sorted.get(4) catch -1000} == 5
 test "list join renders elements correctly with separator"
-  l = List(1, 2, 3)
+  l = Slice(1, 2, 3)
   assert l.join(",") == "1,2,3"
 test "list toStr formats a plain list and a nested list of lists"
-  l := List(1, 2, 3)
+  l := Slice(1, 2, 3)
   assert l.toStr() == "[1,2,3]"
   chunks := l.chunk(2)
   assert chunks.toStr() == "[[1,2],[3]]"
 test "chunk splits into sublists of at most size elements each"
-  l := List(1, 2, 3, 4, 5)
+  l := Slice(1, 2, 3, 4, 5)
   chunks := l.chunk(2)
   assert chunks.length() == 3
   assert chunks.get(0)!.join(",") == "1,2"
@@ -351,7 +351,7 @@ test "chunk splits into sublists of at most size elements each"
   assert l.chunk(0).length() == 0
 test "list_get_set_push_pop: push 1000, get(999), pop until empty, get on empty is an error"
-  l := List[Int]()
+  l := Slice[Int]()
   i := 0
   while i < 1000
     l.push(i)
@@ -372,7 +372,7 @@ test "list_get_set_push_pop: push 1000, get(999), pop until empty, get on empty
   assert {e catch -1} == -1
 test "list_growth: length stays exact across the doubling boundaries"
-  l := List[Int]()
+  l := Slice[Int]()
   i := 0
   while i < 1025
     l.push(i)
@@ -386,7 +386,7 @@ test "list_growth: length stays exact across the doubling boundaries"
   assert l.get(1024)! == 1024
 test "list of strings keeps its elements through growth"
-  l := List[Str]()
+  l := Slice[Str]()
   i := 0
   while i < 40
     l.push("s{i}")
@@ -394,8 +394,8 @@ test "list of strings keeps its elements through growth"
   assert l.get(39)! == "s39"
   assert l.get(16)! == "s16"
-test "List[Float] push/get round-trips"
+test "Slice[Float] push/get round-trips"
-  l := List[Float]()
+  l := Slice[Float]()
   i := 0
   while i < 1000
     l.push(Float(i) + 0.5)
@@ -404,7 +404,7 @@ test "List[Float] push/get round-trips"
   assert l.get(999)! == 999.5
 test "slice is a view: shares storage, no copy"
-  xs := List(1, 2, 3, 4, 5)
+  xs := Slice(1, 2, 3, 4, 5)
   ys := xs.slice(1, 4)
   assert ys.length() == 3
   assert ys.get(0)! == 2
@@ -416,7 +416,7 @@ test "slice is a view: shares storage, no copy"
   assert ys.get(2)! == 40
 test "push on a view copies it out and never overwrites the parent"
-  xs := List(1, 2, 3, 4, 5)
+  xs := Slice(1, 2, 3, 4, 5)
   ys := xs.slice(0, 2)
   ys.push(99)
   assert ys.toStr() == "[1,2,99]"
@@ -425,7 +425,7 @@ test "push on a view copies it out and never overwrites the parent"
   assert xs.get(0)! == 1
 test "a view of a view, clamping, and empty views"
-  xs := List(10, 20, 30, 40, 50, 60)
+  xs := Slice(10, 20, 30, 40, 50, 60)
   ys := xs.slice(1, 5).slice(1, 3)
   assert ys.toStr() == "[30,40]"
   assert xs.slice(-3, 2).toStr() == "[10,20]"
@@ -434,7 +434,7 @@ test "a view of a view, clamping, and empty views"
   assert xs.slice(6, 6).length() == 0
 test "every method indexes from the view's start"
-  xs := List(9, 1, 5, 3, 7, 8)
+  xs := Slice(9, 1, 5, 3, 7, 8)
   v := xs.slice(1, 5)
   assert v.first()! == 1
   assert v.last()! == 7
@@ -442,7 +442,7 @@ test "every method indexes from the view's start"
   assert v.contains(5) && !v.contains(9) && !v.contains(8)
   assert v.findValue(3)! == 3
   assert v.sort(|a, b| a < b).toStr() == "[1,3,5,7]"
-  assert v.equals(List(1, 5, 3, 7))
+  assert v.equals(Slice(1, 5, 3, 7))
   assert v.sublist(1, 3).toStr() == "[5,3]"
   assert v.drop(2).toStr() == "[3,7]"
   assert v.chunk(3).length() == 2
@@ -456,7 +456,7 @@ test "every method indexes from the view's start"
   assert xs.length() == 6
 test "in-place reordering through a view is visible in the parent"
-  xs := List(1, 2, 3, 4, 5)
+  xs := Slice(1, 2, 3, 4, 5)
   v := xs.slice(1, 4)
   _ := v.reverse()
   assert xs.toStr() == "[1,4,3,2,5]"
@@ -465,7 +465,7 @@ test "in-place reordering through a view is visible in the parent"
   assert xs.toStr() == "[1,3,2,2,5]"
 test "a growing list keeps working after a view is taken"
-  xs := List[Int]()
+  xs := Slice[Int]()
   for i := range 20
     xs.push(i)
   v := xs.slice(0, 3)

plum-std/Str.plum CHANGED Viewed

@@ -1,6 +1,6 @@
 module std
-import std/List
+import std/Slice
 import std/Buffer
 import std/Int
 import std/Float
@@ -56,9 +56,9 @@ record Str(data: Array[Byte], start: Int, len: Int) =
   # with them can land in the MIDDLE of a multi-byte character. This is the
   # same design real languages with an efficient string type use (Go, Rust:
   # a byte buffer, with separate codepoint-aware iteration built on top) —
-  # a `List` of codepoints/bytes would need a heap-allocated node PER
+  # a `Slice` of codepoints/bytes would need a heap-allocated node PER
   # CHARACTER with only sequential access, several orders of magnitude
-  # slower for something as basic as string length, and `List` is currently
+  # slower for something as basic as string length, and `Slice` is currently
   # broken for any generic-with-args field regardless (see
   # `plum_generic_field_type_gap`). These three methods are that
   # "codepoint-aware iteration built on top" layer:
@@ -247,8 +247,8 @@ record Str(data: Array[Byte], start: Int, len: Int) =
   # `limit`, with the last element holding everything left unsplit — Go's
   # `strings.SplitN` semantics, not JS's (which instead discards anything
   # past the limit). An empty `separator` splits into individual bytes.
-  fun split(self, separator: Str, limit: Int) -> List[Str] =
+  fun split(self, separator: Str, limit: Int) -> Slice[Str] =
-    result := List[Str]()
+    result := Slice[Str]()
     len := self.length()
     sep_len := separator.length()
     if sep_len == 0

plum-std/Testing.plum CHANGED Viewed

@@ -1,6 +1,6 @@
 module std
-import std/List
+import std/Slice
 import std/Int
 import std/Float
 import std/Str
@@ -17,11 +17,11 @@ import std/Str
 # assertion instead of a raw comparison.
 #
 # `expectArray`/`expectSuccess`/`expectFailure` below take a container
-# type (`List[T]`/`!T`) whose OWN generic param is
+# type (`Slice[T]`/`!T`) whose OWN generic param is
 # nested inside the param type. An error union is inspected with
 # `catch` (`r catch 0`, `r!`); `expectFailureNamed` also checks which error it is.
 #
-# CAVEAT on `expectEq`/`expectNotEq`/`expectObject`/`List.equals`: Plum's
+# CAVEAT on `expectEq`/`expectNotEq`/`expectObject`/`Slice.equals`: Plum's
 # `==`/`!=` have no operator-overloading mechanism. For Int/Str/Bool/Float
 # they do real value comparison (Str is content-compared, not
 # reference-compared). For class/enum instances there is no such override,
@@ -49,9 +49,9 @@ primitive Testing =
   fun expectObject(a: T, b: T) -> Bool =
     a == b
-  # Elementwise `List[T]` comparison — see the module-level CAVEAT above for
+  # Elementwise `Slice[T]` comparison — see the module-level CAVEAT above for
-  # what `List.equals`'s own `==` means when `T` is a class/enum.
+  # what `Slice.equals`'s own `==` means when `T` is a class/enum.
-  fun expectArray(a: List[T], b: List[T]) -> Bool =
+  fun expectArray(a: Slice[T], b: Slice[T]) -> Bool =
     a.equals(b)
   fun expectSuccess(r: !T) -> Bool =
@@ -79,10 +79,10 @@ test "expectEq and expectNotEq"
   assert Testing.expectEq("ab" + "c", "abc")
   assert Testing.expectNotEq(2 + 2, 5)
-test "list equality via the List.equals method"
+test "list equality via the Slice.equals method"
-  a := List(1, 2, 3)
+  a := Slice(1, 2, 3)
-  b := List(1, 2, 3)
+  b := Slice(1, 2, 3)
-  c := List(1, 2)
+  c := Slice(1, 2)
   assert a.equals(b)
   assert Testing.expectFalse(a.equals(c))
@@ -92,14 +92,14 @@ test "error unions are inspected with catch and !"
   assert ok! == 5
   assert {bad catch -1} == -1
-test "expectArray compares two List[T]s elementwise"
+test "expectArray compares two Slice[T]s elementwise"
-  a := List(1, 2, 3)
+  a := Slice(1, 2, 3)
-  b := List(1, 2, 3)
+  b := Slice(1, 2, 3)
-  c := List(1, 2)
+  c := Slice(1, 2)
   assert Testing.expectArray(a, b)
   assert Testing.expectFalse(Testing.expectArray(a, c))
-  d := List("x", "y")
+  d := Slice("x", "y")
-  e := List("x", "y")
+  e := Slice("x", "y")
   assert Testing.expectArray(d, e)
 test "expectSuccess/expectFailure check the right variant"

plum-std/game/Actions.plum CHANGED Viewed

@@ -1,5 +1,5 @@
 module std
-import std/List
+import std/Slice
 import std/Int
 import std/Float
@@ -18,9 +18,9 @@ struct RotateBy(radians: Float, duration: Float, elapsed: Float)
 struct Delay(duration: Float, elapsed: Float)
-record Sequence(steps: List[Action])
+record Sequence(steps: Slice[Action])
-record Parallel(steps: List[Action])
+record Parallel(steps: Slice[Action])
 # `template` is the action restarted each lap, `current` the lap in progress.
 record Forever(template: Action, current: Action)
@@ -36,7 +36,7 @@ record Stepped(pose: Pose, left: Action?, spare: Float)
 # The result of stepping actions side by side: the unfinished ones, and the
 # smallest spare time among the finished ones.
-record SteppedAll(pose: Pose, kept: List[Action], spare: Float)
+record SteppedAll(pose: Pose, kept: Slice[Action], spare: Float)
 primitive Actions =
   fun moveBy(dx: Float, dy: Float, secs: Float) -> Action =
@@ -48,10 +48,10 @@ primitive Actions =
   fun delay(secs: Float) -> Action =
     Delay(duration: secs, elapsed: 0.0)
-  fun sequence(steps: List[Action]) -> Action =
+  fun sequence(steps: Slice[Action]) -> Action =
     Sequence(steps: steps)
-  fun parallel(steps: List[Action]) -> Action =
+  fun parallel(steps: Slice[Action]) -> Action =
     Parallel(steps: steps)
   fun forever(a: Action) -> Action =
@@ -91,7 +91,7 @@ primitive Actions =
         s := Actions.stepAction(p, a.steps.at(0), dt)
         rest := a.steps.drop(1)
         if cur := s.left
-          kept := List[Action]()
+          kept := Slice[Action]()
           kept.push(cur)
           for i := range rest.length()
             kept.push(rest.at(i))
@@ -121,9 +121,9 @@ primitive Actions =
         again: Action := Forever(template: a.template, current: lap)
         Stepped(pose: r.pose, left: again, spare: 0.0)
-  fun stepAll(p: Pose, acts: List[Action], dt: Float) -> SteppedAll =
+  fun stepAll(p: Pose, acts: Slice[Action], dt: Float) -> SteppedAll =
     pose := p
-    kept := List[Action]()
+    kept := Slice[Action]()
     spare := dt
     for i := range acts.length()
       s := Actions.stepAction(pose, acts.at(i), dt)
@@ -148,20 +148,20 @@ fun actPose0() -> Pose =
   Pose(x: 0.0, y: 0.0, rotation: 0.0, scaleX: 1.0, scaleY: 1.0)
 test "stepAll moves partway and keeps the action"
-  r := Actions.stepAll(actPose0(), List(Actions.moveBy(10.0, 0.0, 1.0)), 0.5)
+  r := Actions.stepAll(actPose0(), Slice(Actions.moveBy(10.0, 0.0, 1.0)), 0.5)
   assert actNear(r.pose.x, 5.0)
   assert r.kept.length() == 1
   assert actNear(r.spare, 0.0)
 test "stepAll finishes every action and reports no spare"
-  r := Actions.stepAll(actPose0(), List(Actions.moveBy(10.0, 0.0, 1.0), Actions.rotateBy(1.0, 0.5)), 1.0)
+  r := Actions.stepAll(actPose0(), Slice(Actions.moveBy(10.0, 0.0, 1.0), Actions.rotateBy(1.0, 0.5)), 1.0)
   assert actNear(r.pose.x, 10.0)
   assert actNear(r.pose.rotation, 1.0)
   assert r.kept.length() == 0
   assert actNear(r.spare, 0.0)
 test "stepAll with no actions is a no-op"
-  r := Actions.stepAll(actPose0(), List[Action](), 0.016)
+  r := Actions.stepAll(actPose0(), Slice[Action](), 0.016)
   assert r.kept.length() == 0
   assert actNear(r.spare, 0.016)
   assert actNear(r.pose.x, 0.0)
@@ -184,7 +184,7 @@ test "forever_rotate_no_drift"
   assert actNear(p.rotation, 10.0)
 test "sequence_spills_spare_time"
-  a := Actions.sequence(List(Actions.moveBy(10.0, 0.0, 0.5), Actions.moveBy(0.0, 10.0, 0.5)))
+  a := Actions.sequence(Slice(Actions.moveBy(10.0, 0.0, 0.5), Actions.moveBy(0.0, 10.0, 0.5)))
   r := Actions.stepAction(actPose0(), a, 0.75)
   assert actNear(r.pose.x, 10.0)
   assert actNear(r.pose.y, 5.0)
@@ -195,12 +195,12 @@ test "sequence_spills_spare_time"
     assert false
 test "empty_sequence_finishes_with_full_spare"
-  r := Actions.stepAction(actPose0(), Actions.sequence(List[Action]()), 0.3)
+  r := Actions.stepAction(actPose0(), Actions.sequence(Slice[Action]()), 0.3)
   assert r.left == null
   assert actNear(r.spare, 0.3)
 test "parallel_spare_is_min_of_finished"
-  r := Actions.stepAction(actPose0(), Actions.parallel(List(Actions.delay(0.2), Actions.delay(0.5))), 1.0)
+  r := Actions.stepAction(actPose0(), Actions.parallel(Slice(Actions.delay(0.2), Actions.delay(0.5))), 1.0)
   assert r.left == null
   assert actNear(r.spare, 0.5)
@@ -209,7 +209,7 @@ test "forever_zero_length_template_terminates"
   assert r.left != null
 test "forever of a nested sequence keeps looping"
-  a := Actions.forever(Actions.sequence(List(Actions.moveBy(1.0, 0.0, 0.1), Actions.delay(0.1))))
+  a := Actions.forever(Actions.sequence(Slice(Actions.moveBy(1.0, 0.0, 0.1), Actions.delay(0.1))))
   p := actPose0()
   for i := range 100
     r := Actions.stepAction(p, a, 0.05)

plum-std/game/Picture.plum CHANGED Viewed

@@ -2,6 +2,7 @@ module std
 import std/Int
 import std/Float
 import std/Str
+import std/Slice
 import std/List
 import std/Math
 import std/game/Vec2
@@ -12,7 +13,7 @@ import std/game/Game
 # A recursive picture: a SceneNode is plain data (shapes, sprites, text, groups
 # with a transform, filters) and `Picture` is a set of structurally recursive
 # functions that draw it, measure it and hit-test it. Children are a recursive
-# `Nodes` list, so every operation recurses over SceneNode and Nodes, passing
+# `List[SceneNode]` list, so every operation recurses over SceneNode and List[SceneNode], passing
 # the parent matrix and alpha down as arguments. Nothing here mutates the picture.
 # `Compose(first, then)` applies `then` first, then `first` (`first` is the outermost).
@@ -36,7 +37,7 @@ enum Effect =
 # `target` bounds what the filter can show: child pixels beyond it are cut off.
 # A negative target draws nothing.
 enum SceneNode =
-  | Group(transform: Transform, children: Nodes)
+  | Group(transform: Transform, children: List[SceneNode])
   | Filter(effect: Effect, child: SceneNode, target: Int)
   | Sprite(tex: Int, x: Float, y: Float, w: Float, h: Float, srcX: Float, srcY: Float, srcW: Float, srcH: Float, tint: Color)
   | Text(text: Str, x: Float, y: Float, size: Float, color: Color)
@@ -44,7 +45,6 @@ enum SceneNode =
   | CircleShape(cx: Float, cy: Float, r: Float, color: Color)
   | LineShape(x1: Float, y1: Float, x2: Float, y2: Float, thickness: Float, color: Color)
-enum Nodes = End | More(head: SceneNode, tail: Nodes)
 struct Rect(x: Float, y: Float, w: Float, h: Float)
@@ -91,9 +91,9 @@ fun picBounds(node: SceneNode, m: Affine) -> Rect? = match node
   Group(tr, kids) => picBoundsKids(kids, m.mul(picMatrix(tr)), null)
   Filter(_, child, _) => picBounds(child, m)
-fun picBoundsKids(kids: Nodes, m: Affine, acc: Rect?) -> Rect? = match kids
+fun picBoundsKids(kids: List[SceneNode], m: Affine, acc: Rect?) -> Rect? = match kids
-  End => acc
+  Nil => acc
-  More(head, tail) =>
+  Cons(head, tail) =>
     if cr := picBounds(head, m)
       picBoundsKids(tail, m, picUnion(acc, cr))
     else
@@ -112,21 +112,21 @@ fun picNearLine(x1: Float, y1: Float, x2: Float, y2: Float, thickness: Float, px
   qy := y1 + dy * tc
   Math.hypot(px - qx, py - qy) <= thickness.max(1.0) / 2.0
-fun picLeaf(hit: Bool) -> List[Int]? =
+fun picLeaf(hit: Bool) -> Slice[Int]? =
   if hit
-    return List[Int]()
+    return Slice[Int]()
   null
 # `i` followed by the path `sub`.
-fun picPrepend(i: Int, sub: List[Int]) -> List[Int] =
+fun picPrepend(i: Int, sub: Slice[Int]) -> Slice[Int] =
-  path := List(i)
+  path := Slice(i)
   for j := range sub.length()
     path.push(sub.at(j))
   path
 # The child indices from `node` down to the hit leaf, or null on a miss. A leaf
 # that is hit is an empty path. (px, py) is in `node`'s own space.
-fun picHit(node: SceneNode, px: Float, py: Float) -> List[Int]? = match node
+fun picHit(node: SceneNode, px: Float, py: Float) -> Slice[Int]? = match node
   RectShape(x, y, w, h, _) => picLeaf(picInBox(x, y, w, h, px, py))
   CircleShape(cx, cy, r, _) => picLeaf(Math.hypot(px - cx, py - cy) <= r)
   LineShape(x1, y1, x2, y2, th, _) => picLeaf(picNearLine(x1, y1, x2, y2, th, px, py))
@@ -146,9 +146,9 @@ fun picHit(node: SceneNode, px: Float, py: Float) -> List[Int]? = match node
 # Tries the later children first (they are drawn on top); `i` is the index of
 # `kids`' head. The first hit found from the back wins.
-fun picHitKids(kids: Nodes, i: Int, px: Float, py: Float) -> List[Int]? = match kids
+fun picHitKids(kids: List[SceneNode], i: Int, px: Float, py: Float) -> Slice[Int]? = match kids
-  End => null
+  Nil => null
-  More(head, tail) =>
+  Cons(head, tail) =>
     if later := picHitKids(tail, i + 1, px, py)
       later
     else
@@ -181,9 +181,9 @@ fun picDraw(node: SceneNode, m: Affine, alpha: Float, target: Int) = match node
   Group(tr, kids) => picDrawKids(kids, m.mul(picMatrix(tr)), alpha, target)
   Filter(effect, child, tex) => picFilter(effect, child, tex, m, alpha, target)
-fun picDrawKids(kids: Nodes, m: Affine, alpha: Float, target: Int) = match kids
+fun picDrawKids(kids: List[SceneNode], m: Affine, alpha: Float, target: Int) = match kids
-  End => 0
+  Nil => 0
-  More(head, tail) =>
+  Cons(head, tail) =>
     picDraw(head, m, alpha, target)
     picDrawKids(tail, m, alpha, target)
@@ -224,10 +224,10 @@ primitive Picture =
     Rect(x: 0.0, y: 0.0, w: 0.0, h: 0.0)
   # Child indices from the root down to the topmost hit leaf; empty on a miss.
-  fun hitPath(node: SceneNode, x: Float, y: Float) -> List[Int] =
+  fun hitPath(node: SceneNode, x: Float, y: Float) -> Slice[Int] =
     if p := picHit(node, x, y)
       return p
-    List[Int]()
+    Slice[Int]()
 fun picNear(a: Float, b: Float) -> Bool =
   {a - b}.abs() < 1e-6
@@ -236,7 +236,7 @@ fun picRect(x: Float, y: Float, w: Float, h: Float, c: Color) -> SceneNode =
   RectShape(x: x, y: y, w: w, h: h, color: c)
 test "bounds_translate_scale"
-  g := Group(transform: Compose(first: Translate(dx: 5.0, dy: 5.0), then: Scale(sx: 2.0, sy: 2.0)), children: More(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Red), tail: End))
+  g := Group(transform: Compose(first: Translate(dx: 5.0, dy: 5.0), then: Scale(sx: 2.0, sy: 2.0)), children: Cons(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Red), tail: Nil))
   r := Picture.bounds(g)
   assert picNear(r.x, 5.0)
   assert picNear(r.y, 5.0)
@@ -244,7 +244,7 @@ test "bounds_translate_scale"
   assert picNear(r.h, 20.0)
 test "bounds_rotate_quarter"
-  g := Group(transform: Rotate(radians: 1.5707963267948966), children: More(head: picRect(0.0, 0.0, 10.0, 4.0, Color.Red), tail: End))
+  g := Group(transform: Rotate(radians: 1.5707963267948966), children: Cons(head: picRect(0.0, 0.0, 10.0, 4.0, Color.Red), tail: Nil))
   r := Picture.bounds(g)
   assert picNear(r.x, 0.0 - 4.0)
   assert picNear(r.y, 0.0)
@@ -252,8 +252,8 @@ test "bounds_rotate_quarter"
   assert picNear(r.h, 10.0)
 test "hit_path_nested"
-  inner := Group(transform: Translate(dx: 10.0, dy: 0.0), children: More(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Blue), tail: End))
+  inner := Group(transform: Translate(dx: 10.0, dy: 0.0), children: Cons(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Blue), tail: Nil))
-  g := Group(transform: Identity, children: More(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Red), tail: More(head: inner, tail: End)))
+  g := Group(transform: Identity, children: Cons(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Red), tail: Cons(head: inner, tail: Nil)))
   p := Picture.hitPath(g, 15.0, 5.0)
   assert p.length() == 2
   assert p.at(0) == 1
@@ -263,13 +263,13 @@ test "hit_path_nested"
   assert q.at(0) == 0
 test "hit_path_last_child_wins"
-  g := Group(transform: Identity, children: More(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Red), tail: More(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Blue), tail: End)))
+  g := Group(transform: Identity, children: Cons(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Red), tail: Cons(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Blue), tail: Nil)))
   p := Picture.hitPath(g, 5.0, 5.0)
   assert p.length() == 1
   assert p.at(0) == 1
 test "hit_miss_empty"
-  g := Group(transform: Identity, children: More(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Red), tail: End))
+  g := Group(transform: Identity, children: Cons(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Red), tail: Nil))
   assert Picture.hitPath(g, 50.0, 50.0).length() == 0
 test "filter_bounds_is_child_bounds"

plum-std/game/PureScene.plum CHANGED Viewed

@@ -2,7 +2,7 @@ module std
 import std/Int
 import std/Float
 import std/Str
-import std/List
+import std/Slice
 import std/Math
 import std/game/Vec2
 import std/game/Color
@@ -39,7 +39,7 @@ enum UiKind =
 record UiEvent(id: Int, kind: UiKind)
 # The actor after handling an event, and the events it raised.
-own record Handled(actor: Actor, events: List[UiEvent]) =
+own record Handled(actor: Actor, events: Slice[UiEvent]) =
   # The actor, moved out; read `events` first, they stay behind.
   fun intoActor(own self) -> Actor =
@@ -55,13 +55,13 @@ own trait Actor(
   color: Color,
   visible: Bool,
   touchable: Touchable,
-  actions: List[Action]) =
+  actions: Slice[Action]) =
   # This actor after `dt` seconds of its own behaviour; the default is itself.
   fun act(own self, dt: Float) -> Actor = self
   # The children of a group; null for a leaf.
-  fun kids(self) -> List[Actor]? = null
+  fun kids(self) -> Slice[Actor]? = null
   # Paints this actor only, at its stage transform `m` with the combined `tint`.
   fun draw(self, m: Affine, tint: Color) =
@@ -73,14 +73,14 @@ own trait Actor(
   # Handles a pointer event and returns the new actor with the events it raised.
   fun onPointer(own self, e: Pointer) -> Handled =
-    Handled(actor: self, events: List[UiEvent]())
+    Handled(actor: self, events: Slice[UiEvent]())
 own record Group(
   Actor(id, x, y, width, height, originX, originY, scaleX, scaleY, rotation, color, visible, touchable, actions),
-  children: List[Actor]) =
+  children: Slice[Actor]) =
-  override fun kids(self) -> List[Actor]? = self.children
+  override fun kids(self) -> Slice[Actor]? = self.children
 own record Sprite(
   Actor(id, x, y, width, height, originX, originY, scaleX, scaleY, rotation, color, visible, touchable, actions),
@@ -114,7 +114,7 @@ own record Button(
     pureDrawText(m.mul(Affine(a: 1.0, b: 0.0, c: 0.0, d: 1.0, e: ox, f: oy)), tint, self.text, size)
   override fun onPointer(own self, e: Pointer) -> Handled =
-    ev := List[UiEvent]()
+    ev := Slice[UiEvent]()
     id := self.id
     wasOver := self.over
     wasPressed := self.pressed
@@ -178,37 +178,37 @@ primitive PureScene =
         PureScene.drawTree(g.at(i), m, t)
   # The children of a group, or null for a leaf.
-  fun childrenOf(a: Actor) -> List[Actor]? =
+  fun childrenOf(a: Actor) -> Slice[Actor]? =
     a.kids()
-  fun group(id: Int, x: Float, y: Float, w: Float, h: Float, children: List[Actor]) -> Group =
+  fun group(id: Int, x: Float, y: Float, w: Float, h: Float, children: Slice[Actor]) -> Group =
     Group(
       id: id, x: x, y: y, width: w, height: h, originX: 0.0, originY: 0.0,
       scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: Color.White, visible: true,
-      touchable: Enabled, actions: List[Action](), children: children)
+      touchable: Enabled, actions: Slice[Action](), children: children)
   fun sprite(id: Int, tex: Int, x: Float, y: Float, w: Float, h: Float) -> Sprite =
     Sprite(
       id: id, x: x, y: y, width: w, height: h, originX: 0.0, originY: 0.0,
       scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: Color.White, visible: true,
-      touchable: Enabled, actions: List[Action](),
+      touchable: Enabled, actions: Slice[Action](),
       tex: tex, srcX: 0.0, srcY: 0.0, srcW: 0.0, srcH: 0.0)
   fun label(id: Int, text: Str, x: Float, y: Float, size: Float) -> Label =
     Label(
       id: id, x: x, y: y, width: size * 0.6 * Float(text.length()), height: size, originX: 0.0, originY: 0.0,
       scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: Color.White, visible: true,
-      touchable: Disabled, actions: List[Action](), text: text, size: size)
+      touchable: Disabled, actions: Slice[Action](), text: text, size: size)
   fun button(id: Int, text: Str, upTex: Int, downTex: Int, x: Float, y: Float, w: Float, h: Float) -> Button =
     Button(
       id: id, x: x, y: y, width: w, height: h, originX: 0.0, originY: 0.0,
       scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: Color.White, visible: true,
-      touchable: Enabled, actions: List[Action](),
+      touchable: Enabled, actions: Slice[Action](),
       text: text, upTex: upTex, downTex: downTex, pressed: false, over: false)
-fun psKinds(h: Handled) -> List[UiKind] =
+fun psKinds(h: Handled) -> Slice[UiKind] =
-  out := List[UiKind]()
+  out := Slice[UiKind]()
   for i := range h.events.length()
     out.push(h.events.at(i).kind)
   out

plum-std/game/Scene.plum CHANGED Viewed

@@ -2,7 +2,7 @@ module std
 import std/Int
 import std/Float
 import std/Str
-import std/List
+import std/Slice
 import std/Math
 import std/game/Vec2
 import std/game/Color
@@ -50,9 +50,9 @@ trait Actor(
   rotation: Float,
   color: Color,
   visible: Bool,
-  children: List[Actor],
+  children: Slice[Actor],
   parent: Actor?,
-  scratch: List[Actor],
+  scratch: Slice[Actor],
   cull: Bool, cullX: Float, cullY: Float, cullW: Float, cullH: Float) =
   # Runs for every construction, before the record's own `init`. A record's header
@@ -69,9 +69,9 @@ trait Actor(
     self.rotation = 0.0
     self.color = Color.White
     self.visible = true
-    self.children = List[Actor]()
+    self.children = Slice[Actor]()
     self.parent = null
-    self.scratch = List[Actor]()
+    self.scratch = Slice[Actor]()
     self.cull = false
     self.cullX = 0.0
     self.cullY = 0.0
@@ -271,7 +271,7 @@ trait Actor(
       if !self.culls(kid)
         kid.drawTree(m, a)
-  fun collect(self, parent: Affine, alpha: Float, out: List[Drawn]) =
+  fun collect(self, parent: Affine, alpha: Float, out: Slice[Drawn]) =
     if !self.visible
       return
     m := parent * self.local()
@@ -388,7 +388,7 @@ fun sortRunEnd(d: Array[Actor], base: Int, i: Int, n: Int, before: fn(Actor, Act
 # Merges the sorted runs [lo, a) and [a, b) of `d`, stably. The left elements that
 # already precede the first right one and the right elements that already follow
 # the last left one are found by binary search and left alone.
-fun sortMerge(scratch: List[Actor], d: Array[Actor], base: Int, lo: Int, a: Int, b: Int, before: fn(Actor, Actor) -> Bool) =
+fun sortMerge(scratch: Slice[Actor], d: Array[Actor], base: Int, lo: Int, a: Int, b: Int, before: fn(Actor, Actor) -> Bool) =
   first := d.get(base + a)
   l := lo
   h := a
@@ -450,8 +450,8 @@ record Drawn(node: Actor, m: Affine, alpha: Float)
 # What `draw` would draw, in order: a parent before its children, siblings in
 # list order, invisible and culled subtrees left out.
-fun flatten(root: Actor) -> List[Drawn] =
+fun flatten(root: Actor) -> Slice[Drawn] =
-  out := List[Drawn]()
+  out := Slice[Drawn]()
   root.collect(Affine.Identity, 1.0, out)
   out
@@ -709,7 +709,7 @@ test "sorting a nearly sorted list takes about n comparisons and reuses the scra
   g := Group()
   for i := range 5000
     g.add(Rect.create(1.0, 1.0, Color.Red).at(0.0, Float(i)))
-  c := List(0)
+  c := Slice(0)
   less: fn(Actor, Actor) -> Bool := |a, b|
     _ := c.set(0, c.at(0) + 1)
     a.y < b.y

plum-std/game/SceneInput.plum CHANGED Viewed

@@ -2,7 +2,7 @@ module std
 import std/Int
 import std/Float
 import std/Str
-import std/List
+import std/Slice
 import std/game/Vec2
 import std/game/Color
 import std/game/Affine
@@ -26,9 +26,9 @@ enum InputKind =
 # A pointer input in screen coordinates.
 record Input(kind: InputKind, x: Float, y: Float)
-record Capture(path: List[Int], id: Int)
+record Capture(path: Slice[Int], id: Int)
-own record StageHandled(stage: Stage, events: List[UiEvent]) =
+own record StageHandled(stage: Stage, events: Slice[UiEvent]) =
   # The stage, moved out; read `events` first, they stay behind.
   fun intoStage(own self) -> Stage =
@@ -39,7 +39,7 @@ own record Stage(root: Actor, camera: Affine, captured: Capture?) =
   # Handles one input: routes it, returns the new stage and the events raised.
   fun input(own self, e: Input) -> StageHandled =
-    none := List[UiEvent]()
+    none := Slice[UiEvent]()
     inv := self.camera.invert()
     if inv == null
       return StageHandled(stage: self, events: none)
@@ -74,16 +74,16 @@ own record Stage(root: Actor, camera: Affine, captured: Capture?) =
     self.captured = c
     self
-  fun deliver(own self, path: List[Int], p: Pointer, c: Capture?) -> StageHandled =
+  fun deliver(own self, path: Slice[Int], p: Pointer, c: Capture?) -> StageHandled =
-    events := List[UiEvent]()
+    events := Slice[UiEvent]()
     self.root = SceneTree.routeInto(self.root, path, 0, p, events)
     self.captured = c
     StageHandled(stage: self, events: events)
   # Handles the inputs in order, then advances the tree by `dt`.
-  fun frame(own self, dt: Float, inputs: List[Input]) -> StageHandled =
+  fun frame(own self, dt: Float, inputs: Slice[Input]) -> StageHandled =
     cur := self
-    out := List[UiEvent]()
+    out := Slice[UiEvent]()
     for i := range inputs.length()
       h := cur.input(inputs.at(i))
       for j := range h.events.length()
@@ -96,7 +96,7 @@ own record Stage(root: Actor, camera: Affine, captured: Capture?) =
   fun draw(self) =
     PureScene.drawTree(self.root, self.camera, Color.White)
-fun inputIsPrefix(a: List[Int], b: List[Int]) -> Bool =
+fun inputIsPrefix(a: Slice[Int], b: Slice[Int]) -> Bool =
   if a.length() > b.length()
     return false
   for i := range a.length()
@@ -110,10 +110,10 @@ primitive SceneInput =
   # This frame's pointer inputs from the host mouse: a press, a release, or a
   # move. `wasDown` is whether the button was down last frame.
-  fun pollPointer(wasDown: Bool) -> List[Input] =
+  fun pollPointer(wasDown: Bool) -> Slice[Input] =
     m := mousePos()
     down := isMouseDown(0)
-    out := List[Input]()
+    out := Slice[Input]()
     if down && !wasDown
       out.push(Input(kind: PointerDown, x: m.x, y: m.y))
     else if !down && wasDown
@@ -124,7 +124,7 @@ primitive SceneInput =
 fun inBtnTree() -> Actor =
   b: Actor := PureScene.button(5, "Go", 0, 1, 10.0, 10.0, 100.0, 40.0)
-  kids := List[Actor]()
+  kids := Slice[Actor]()
   kids.push(b)
   g: Actor := PureScene.group(1, 0.0, 0.0, 800.0, 600.0, kids)
   g
@@ -153,7 +153,7 @@ fun inUp(x: Float, y: Float) -> Input =
 fun inMove(x: Float, y: Float) -> Input =
   Input(kind: PointerMove, x: x, y: y)
-fun inClicks(events: List[UiEvent]) -> Int =
+fun inClicks(events: Slice[UiEvent]) -> Int =
   n := 0
   for i := range events.length()
     if events.at(i).kind == Click
@@ -162,7 +162,7 @@ fun inClicks(events: List[UiEvent]) -> Int =
 fun inXformTree() -> Actor =
   b: Actor := PureScene.button(5, "Go", 0, 1, 10.0, 10.0, 100.0, 40.0)
-  kids := List[Actor]()
+  kids := Slice[Actor]()
   kids.push(b)
   g := PureScene.group(1, 100.0, 0.0, 800.0, 600.0, kids)
   g.rotation = 1.5707963267948966
@@ -202,7 +202,7 @@ test "drag_off_and_back_one_click"
 test "stale_capture_dropped"
   h1 := SceneInput.stage(inBtnTree()).input(inDown(20.0, 20.0))
-  empty: Actor := PureScene.group(1, 0.0, 0.0, 800.0, 600.0, List[Actor]())
+  empty: Actor := PureScene.group(1, 0.0, 0.0, 800.0, 600.0, Slice[Actor]())
   swapped := Stage(root: empty, camera: h1.stage.camera, captured: h1.stage.captured)
   h2 := swapped.input(inUp(20.0, 20.0))
   assert h2.events.length() == 0
@@ -223,16 +223,16 @@ test "camera_maps_screen_to_world"
 test "frame_handles_inputs_then_updates"
   spr := PureScene.sprite(6, 0, 300.0, 300.0, 10.0, 10.0)
-  acts := List[Action]()
+  acts := Slice[Action]()
   acts.push(Actions.moveBy(10.0, 0.0, 1.0))
   spr.actions = acts
   b: Actor := PureScene.button(5, "Go", 0, 1, 10.0, 10.0, 100.0, 40.0)
   sp: Actor := spr
-  kids := List[Actor]()
+  kids := Slice[Actor]()
   kids.push(b)
   kids.push(sp)
   root: Actor := PureScene.group(1, 0.0, 0.0, 800.0, 600.0, kids)
-  ins := List[Input]()
+  ins := Slice[Input]()
   ins.push(inDown(20.0, 20.0))
   ins.push(inUp(20.0, 20.0))
   h := SceneInput.stage(root).frame(0.5, ins)

plum-std/game/SceneTree.plum CHANGED Viewed

@@ -1,15 +1,15 @@
 module std
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 import std/Str
 import std/game/Vec2
 import std/game/Affine
 import std/game/Actions
 import std/game/PureScene
-fun treePrepend(i: Int, rest: List[Int]) -> List[Int] =
+fun treePrepend(i: Int, rest: Slice[Int]) -> Slice[Int] =
-  out := List[Int]()
+  out := Slice[Int]()
   out.push(i)
   for j := range rest.length()
     out.push(rest.at(j))
@@ -34,7 +34,7 @@ primitive SceneTree =
   # The path (child indexes from `a`) to the topmost actor under `p`, which is
   # in the coordinates of `a`'s parent; `parent` is that parent's stage matrix.
-  fun findHit(a: Actor, parent: Affine, p: Vec2) -> List[Int]? =
+  fun findHit(a: Actor, parent: Affine, p: Vec2) -> Slice[Int]? =
     if !a.visible || a.touchable == Disabled
       return null
     m := parent * PureScene.localMatrix(a)
@@ -52,11 +52,11 @@ primitive SceneTree =
           return treePrepend(i, s)
         i = i - 1
     if a.hit(lp)
-      return List[Int]()
+      return Slice[Int]()
     null
   # The id of the actor at `path` below `a`, or -1 if the path leads nowhere.
-  fun idAt(a: Actor, path: List[Int], depth: Int) -> Int =
+  fun idAt(a: Actor, path: Slice[Int], depth: Int) -> Int =
     if depth >= path.length()
       return a.id
     if ks := a.kids()
@@ -66,9 +66,9 @@ primitive SceneTree =
     -1
   # The path to the first actor with `id`, depth first; null if none.
-  fun findPath(a: Actor, id: Int) -> List[Int]? =
+  fun findPath(a: Actor, id: Int) -> Slice[Int]? =
     if a.id == id
-      return List[Int]()
+      return Slice[Int]()
     if ks := a.kids()
       for i := range ks.length()
         sub := SceneTree.findPath(ks.at(i), id)
@@ -83,7 +83,7 @@ primitive SceneTree =
       return SceneTree.modifyAt(a, p, 0, f)
     a
-  fun modifyAt(own a: Actor, path: List[Int], depth: Int, f: fn(Actor) -> Actor) -> Actor =
+  fun modifyAt(own a: Actor, path: Slice[Int], depth: Int, f: fn(Actor) -> Actor) -> Actor =
     if depth >= path.length()
       return f(a)
     if ks := a.kids()
@@ -96,13 +96,13 @@ primitive SceneTree =
   # Delivers `e` (in the coordinates of `a`'s parent) along `path`: the child on
   # the path first, then `a` itself. A path that runs out reaches the deepest
   # actor it can.
-  fun route(own a: Actor, path: List[Int], depth: Int, e: Pointer) -> Handled =
+  fun route(own a: Actor, path: Slice[Int], depth: Int, e: Pointer) -> Handled =
-    events := List[UiEvent]()
+    events := Slice[UiEvent]()
     r := SceneTree.routeInto(a, path, depth, e, events)
     Handled(actor: r, events: events)
   # `route`, appending the raised events to `events` and returning the actor.
-  fun routeInto(own a: Actor, path: List[Int], depth: Int, e: Pointer, events: List[UiEvent]) -> Actor =
+  fun routeInto(own a: Actor, path: Slice[Int], depth: Int, e: Pointer, events: Slice[UiEvent]) -> Actor =
     lp := Vec2(x: e.x, y: e.y)
     inv := PureScene.localMatrix(a).invert()
     if q := inv
@@ -120,19 +120,19 @@ primitive SceneTree =
     h.intoActor()
 fun ttFixture() -> Actor =
-  inner := List[Actor]()
+  inner := Slice[Actor]()
   inner.push(PureScene.sprite(4, 0, 0.0, 0.0, 5.0, 5.0))
-  kids := List[Actor]()
+  kids := Slice[Actor]()
   kids.push(PureScene.sprite(2, 0, 0.0, 0.0, 10.0, 10.0))
   kids.push(PureScene.group(3, 20.0, 0.0, 10.0, 10.0, inner))
   root := PureScene.group(1, 0.0, 0.0, 100.0, 100.0, kids)
   me: Actor := root
   me
-fun ttNoPath(r: List[Int]?) -> Bool =
+fun ttNoPath(r: Slice[Int]?) -> Bool =
   r == null
-fun ttPathEq(r: List[Int]?, want: List[Int]) -> Bool =
+fun ttPathEq(r: Slice[Int]?, want: Slice[Int]) -> Bool =
   if p := r
     if p.length() != want.length()
       return false
@@ -142,8 +142,8 @@ fun ttPathEq(r: List[Int]?, want: List[Int]) -> Bool =
     return true
   false
-fun ttInts(a: Int, b: Int) -> List[Int] =
+fun ttInts(a: Int, b: Int) -> Slice[Int] =
-  out := List[Int]()
+  out := Slice[Int]()
   out.push(a)
   out.push(b)
   out
@@ -153,8 +153,8 @@ fun ttAt(x: Float, y: Float) -> Vec2 =
 fun ttMovingTree() -> Actor =
   s := PureScene.sprite(2, 0, 0.0, 0.0, 10.0, 10.0)
-  s.actions = List(Actions.moveBy(10.0, 0.0, 1.0))
+  s.actions = Slice(Actions.moveBy(10.0, 0.0, 1.0))
-  kids := List[Actor]()
+  kids := Slice[Actor]()
   kids.push(s)
   root := PureScene.group(1, 0.0, 0.0, 100.0, 100.0, kids)
   me: Actor := root
@@ -194,14 +194,14 @@ fun ttKidX(a: Actor, i: Int) -> Float =
   0.0 - 1.0
 fun ttButtonRoot() -> Actor =
-  kids := List[Actor]()
+  kids := Slice[Actor]()
   kids.push(PureScene.button(5, "Go", 0, 1, 10.0, 10.0, 100.0, 40.0))
   root := PureScene.group(1, 0.0, 0.0, 800.0, 600.0, kids)
   me: Actor := root
   me
-fun ttZero() -> List[Int] =
+fun ttZero() -> Slice[Int] =
-  out := List[Int]()
+  out := Slice[Int]()
   out.push(0)
   out
@@ -215,10 +215,10 @@ test "find_hit_miss"
 test "id_at_paths"
   t := ttFixture()
   assert SceneTree.idAt(t, ttInts(1, 0), 0) == 4
-  five := List[Int]()
+  five := Slice[Int]()
   five.push(5)
   assert SceneTree.idAt(t, five, 0) == -1
-  assert SceneTree.idAt(t, List[Int](), 0) == 1
+  assert SceneTree.idAt(t, Slice[Int](), 0) == 1
 test "find_path_ids"
   t := ttFixture()
@@ -239,31 +239,31 @@ test "update_changes_tree_in_place"
 test "disabled_group_hides_subtree"
   t := ttSetTouch(ttFixture(), 3, Disabled)
   r := SceneTree.findHit(t, Affine.Identity, ttAt(21.0, 1.0))
-  assert ttPathEq(r, List[Int]())
+  assert ttPathEq(r, Slice[Int]())
 test "children_only_group_not_hit_itself"
   t := ttSetTouch(ttFixture(), 3, ChildrenOnly)
   r := SceneTree.findHit(t, Affine.Identity, ttAt(28.0, 8.0))
-  assert ttPathEq(r, List[Int]())
+  assert ttPathEq(r, Slice[Int]())
 test "scale_zero_not_hit"
   t := SceneTree.modify(ttFixture(), 2, |a| ttSetScaleX(a))
   r := SceneTree.findHit(t, Affine.Identity, ttAt(1.0, 1.0))
-  assert ttPathEq(r, List[Int]())
+  assert ttPathEq(r, Slice[Int]())
 test "topmost_child_wins"
-  kids := List[Actor]()
+  kids := Slice[Actor]()
   kids.push(PureScene.sprite(2, 0, 0.0, 0.0, 10.0, 10.0))
   kids.push(PureScene.sprite(3, 0, 0.0, 0.0, 10.0, 10.0))
   root := PureScene.group(1, 0.0, 0.0, 100.0, 100.0, kids)
   me: Actor := root
   r := SceneTree.findHit(me, Affine.Identity, ttAt(1.0, 1.0))
-  want := List[Int]()
+  want := Slice[Int]()
   want.push(1)
   assert ttPathEq(r, want)
 test "modify_changes_first_match_only"
-  kids := List[Actor]()
+  kids := Slice[Actor]()
   kids.push(PureScene.sprite(7, 0, 0.0, 0.0, 10.0, 10.0))
   kids.push(PureScene.sprite(7, 0, 0.0, 0.0, 10.0, 10.0))
   root := PureScene.group(1, 0.0, 0.0, 100.0, 100.0, kids)
@@ -286,7 +286,7 @@ test "route_child_first_then_group"
   assert h2.events.at(1).id == 5
 test "stale_path_reaches_group_only"
-  nine := List[Int]()
+  nine := Slice[Int]()
   nine.push(9)
   h := SceneTree.route(ttButtonRoot(), nine, 0, Pointer(kind: Down, x: 20.0, y: 20.0, over: true))
   assert h.events.length() == 0

plum-wasm-codegen/src/lib.rs CHANGED Viewed

@@ -1206,6 +1206,67 @@ fn addTraitParams(
     }
 }
+/// A union-enum member or inline-variant record laid out as a wasm-gc subtype of
+/// its enum (no wrapper struct): `record` is the member record, `hidden` the
+/// hidden wrapper variant of `enumName` that now resolves to the record's struct.
+/// `memberArgs` are the enum generics the member's type arguments name, in order.
+struct UnboxedMember {
+    enumName: String,
+    hidden: String,
+    record: String,
+    memberArgs: Vec<String>,
+}
+/// Members eligible for the unboxed layout: records claimed by exactly one enum
+/// (a struct has one supertype), not already subtypes of a trait, whose enum has
+/// no shared params, and whose type arguments are exactly the enum's generics.
+fn unboxedMembers(
+    source: &ast::Source,
+    enum_decls: &HashMap<String, &ast::Enum>,
+    parent_of: &HashMap<String, String>,
+) -> Vec<UnboxedMember> {
+    let mut found: Vec<UnboxedMember> = Vec::new();
+    for item in &source.items {
+        let ast::Item::Enum(e) = item else { continue };
+        if e.isValue || e.isRecord || e.isTrait || !e.params.is_empty() {
+            continue;
+        }
+        for v in &e.variants {
+            let Some(m) = &v.member else { continue };
+            if v.name != plum_core::unions::hiddenVariant(&e.name, &m.name) {
+                continue;
+            }
+            let Some(r) = enum_decls.get(&m.name) else { continue };
+            if !r.isRecord || r.isValue || parent_of.contains_key(&m.name) {
+                continue;
+            }
+            if r.generics.len() != m.generics.len() {
+                continue;
+            }
+            let names: Vec<String> = m.generics.iter().map(|g| g.name.clone()).collect();
+            let plain = m.generics.iter().all(|g| g.generics.is_empty())
+                && names.iter().all(|n| e.generics.iter().any(|p| &p.name == n));
+            let covers = e.generics.iter().all(|p| names.contains(&p.name));
+            let distinct = names.iter().collect::<HashSet<_>>().len() == names.len();
+            if !(plain && covers && distinct) {
+                continue;
+            }
+            found.push(UnboxedMember {
+                enumName: e.name.clone(),
+                hidden: v.name.clone(),
+                record: m.name.clone(),
+                memberArgs: names,
+            });
+        }
+    }
+    let mut count: HashMap<String, usize> = HashMap::new();
+    for u in &found {
+        *count.entry(u.record.clone()).or_default() += 1;
+    }
+    found.retain(|u| count[&u.record] == 1);
+    found
+}
 /// Builds the wasm-gc type registry: one struct family per non-generic enum and per
 /// distinct concrete instance (`apps`, e.g. `List[Int]`) of a generic enum, keyed by
 /// the structural `PlumType`; `Array[T]` instances become native wasm arrays of `T`'s
@@ -1262,6 +1323,7 @@ fn buildGcTypeRegistry(
             instances.push(PlumType::TNamed(e.name.clone()));
         }
     }
+    let unboxed = unboxedMembers(source, &enum_decls, &parent_of);
     let mut arrays: Vec<PlumType> = Vec::new();
     for a in apps {
         if let PlumType::TApp(n, _) = a {
@@ -1272,9 +1334,48 @@ fn buildGcTypeRegistry(
             }
         }
     }
+    // Unboxed members: member record instance -> (enum instance, hidden variant).
+    // Every claimed member instance of an included enum instance must exist.
+    let mut member_parent: HashMap<PlumType, (PlumType, String)> = HashMap::new();
+    let mut k = 0;
+    while k < instances.len() {
+        let ty = instances[k].clone();
+        k += 1;
+        let Some(n) = plum_checker::nominalName(&ty) else { continue };
+        for (hidden, um) in unboxed.iter().filter(|u| u.enumName == n).map(|u| (&u.hidden, u)) {
+            let args: Vec<PlumType> = match &ty {
+                PlumType::TApp(_, args) => um
+                    .memberArgs
+                    .iter()
+                    .map(|g| {
+                        let i = enum_decls[n].generics.iter().position(|p| &p.name == g).unwrap();
+                        args[i].clone()
+                    })
+                    .collect(),
+                _ => Vec::new(),
+            };
+            let mty = if args.is_empty() {
+                PlumType::TNamed(um.record.clone())
+            } else {
+                PlumType::TApp(um.record.clone(), args)
+            };
+            if !instances.contains(&mty) {
+                instances.push(mty.clone());
+            }
+            member_parent.insert(mty, (ty.clone(), hidden.clone()));
+        }
+    }
-    // A trait's base struct must precede the records that extend it.
+    // A trait's base struct, then unboxed enum supers, must precede the records
+    // that extend them.
     instances.sort_by_key(|t| {
+        let n = plum_checker::nominalName(t).unwrap_or("");
-        !matches!(t, PlumType::TNamed(n) if subtyped.contains_key(n))
+        if subtyped.contains_key(n) {
+            0
+        } else if unboxed.iter().any(|u| u.enumName == n) {
+            1
+        } else {
+            2
+        }
     });
     for ty in &instances {
         let n = plum_checker::nominalName(ty).unwrap().to_string();
@@ -1294,6 +1395,9 @@ fn buildGcTypeRegistry(
             continue;
         }
         for v in &e.variants {
+            if unboxed.iter().any(|u| u.enumName == n && u.hidden == v.name) {
+                continue;
+            }
             let idx = slots.len() as u32;
             slots.push(Slot::Variant(ty.clone(), v.name.clone()));
             match ty {
@@ -1325,6 +1429,18 @@ fn buildGcTypeRegistry(
             }
         }
     }
+    for (mty, (ety, hidden)) in &member_parent {
+        let Some(idx) = reg.classIdx(mty) else { continue };
+        match ety {
+            PlumType::TNamed(_) => {
+                reg.variant_type_idx.insert(hidden.clone(), idx);
+            }
+            _ => {
+                reg.app_variant.insert((ety.clone(), hidden.clone()), idx);
+            }
+        }
+        reg.trait_members.insert(hidden.clone());
+    }
     reg.instances = instances.clone();
     for t in errs {
         if !reg.err_box.contains_key(t) {
@@ -1443,6 +1559,11 @@ fn buildGcTypeRegistry(
                     PlumType::TNamed(n) if *vname == *n && parent_of.contains_key(n) => {
                         reg.enum_super_type_idx[&parent_of[n]]
                     }
+                    _ if plum_checker::nominalName(ty) == Some(vname.as_str())
+                        && member_parent.contains_key(ty) =>
+                    {
+                        reg.superIdx(&member_parent[ty].0).expect("enum supertype slot")
+                    }
                     _ => reg.superIdx(ty).expect("enum supertype slot"),
                 };
                 let mut field_types: Vec<FieldType> = Vec::new();
@@ -7537,10 +7658,12 @@ fn compileExprCore(
             // positional-variant-construction case just below — see the matching
             // comment in `plum-checker`'s `inferExpr` for why a record-shaped
             // enum's own name needs this precedence.
-            } else if ctx
+            } else if (ctx
                 .enum_variants
                 .get(&call.name)
                 .is_some_and(|info| info.enum_name == call.name)
+                || (!ctx.enum_variants.contains_key(&call.name)
+                    && ctx.enum_variants.values().any(|i| i.enum_name == call.name)))
                 && ctx
                     .methods
                     .contains_key(&(call.name.clone(), "init".to_string()))
@@ -8371,6 +8494,17 @@ fn compileVariantConstruction(
             call.name, ety
         )
     })?;
+    if ctx.gc_types.trait_members.contains(&call.name) && call.args.len() == 1 {
+        // The member record IS the enum value: no wrapper struct.
+        let arg = match &call.args[0] {
+            ast::Arg::Positional(e) => e,
+            ast::Arg::Keyword { value, .. } => value,
+        };
+        return match field_tys.first() {
+            Some(d) => compileExprIntoHeap(arg, d, body, ctx, state),
+            None => compileExpr(arg, body, ctx, state),
+        };
+    }
     if info.field_types.is_empty() {
         // Pre-allocated singleton (this migration plan's Decision 2) — not a fresh
         // struct.new per reference.

plum-wasm-codegen/tests/codegen_tests.rs CHANGED Viewed

@@ -518,7 +518,7 @@ fn wasmtimeGcConfigSupportsSubtypingRefTestAndNullableSelfReferentialFields() {
     // Deeper empirical check: enum-variant subtyping (abstract supertype + concrete
     // subtypes in one `rec` group), ref.test-based dispatch, ref.cast to narrow to a
     // subtype, and a nullable field that references the struct's OWN type (the
-    // Node.next: Link[Node] shape List needs) — all in one hand-encoded module,
+    // Node.next: Link[Node] shape Slice needs) — all in one hand-encoded module,
     // bypassing plum entirely.
     use wasm_encoder::*;
@@ -1112,20 +1112,20 @@ fn compiledKeys(name: &str, src: &str) -> (Vec<u8>, Vec<String>) {
 }
 const LIST_FNS: &str = "\
-fun mapList(xs: List[T], cb: fn(T) -> U) -> List[U] =
+fun mapList(xs: Slice[T], cb: fn(T) -> U) -> Slice[U] =
-  result := List[U]()
+  result := Slice[U]()
   for x := range xs
     result.push(cb(x))
   result
-fun reduceList(xs: List[T], acc: U, cb: fn(U, T) -> U) -> U =
+fun reduceList(xs: Slice[T], acc: U, cb: fn(U, T) -> U) -> U =
   result := acc
   for x := range xs
     result = cb(result, x)
   result
-fun retainList(xs: List[T], keep: fn(T) -> Bool) -> List[T] =
+fun retainList(xs: Slice[T], keep: fn(T) -> Bool) -> Slice[T] =
-  result := List[T]()
+  result := Slice[T]()
   for x := range xs
     if keep(x)
       result.push(x)
@@ -1137,7 +1137,7 @@ const STD_HEAD: &str = "\
 import std/Str
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 ";
 #[test]
@@ -1145,8 +1145,8 @@ fn one_copy_per_distinct_type() {
     let src = format!(
         "{}{}\
 fun main() -> Int =
-  a := mapList(List(1, 2), |n| n + 1)
+  a := mapList(Slice(1, 2), |n| n + 1)
-  b := mapList(List(\"x\", \"y\"), |s| s + \"!\")
+  b := mapList(Slice(\"x\", \"y\"), |s| s + \"!\")
   a.length() + b.length()
 ",
         STD_HEAD, LIST_FNS
@@ -1174,8 +1174,8 @@ fun main() -> Int =
     let src = format!(
         "{}{}\
 fun main() -> Int =
-  a := mapList(List(1, 2), |n| n + 1)
+  a := mapList(Slice(1, 2), |n| n + 1)
-  b := mapList(List(3), |n| n * 2)
+  b := mapList(Slice(3), |n| n * 2)
   a.length() + b.length()
 ",
         STD_HEAD, LIST_FNS
@@ -1193,7 +1193,7 @@ fun neverUsed(x: T) -> T =
   x
 fun main() -> Int =
-  List(1, 2).length()
+  Slice(1, 2).length()
 ",
         STD_HEAD
     );
@@ -1254,7 +1254,7 @@ fn no_boxes_in_list_int_map() {
     let src = format!(
         "{}{}\
 fun main() -> Int =
-  mapList(List(1, 2), |n| n + 1).length()
+  mapList(Slice(1, 2), |n| n + 1).length()
 ",
         STD_HEAD, LIST_FNS
     );
@@ -1307,7 +1307,7 @@ fn array_int_native() {
     let src = format!(
         "{}\
 fun main() -> Int =
-  List(1, 2).length()
+  Slice(1, 2).length()
 ",
         STD_HEAD
     );
@@ -1385,10 +1385,10 @@ fn builtin_bool_list_round_trip() {
 import std/Str
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 fun main() -> Int =
-  l := List[Bool]()
+  l := Slice[Bool]()
   l.push(true)
   l.push(false)
   l.push(true)
@@ -1605,11 +1605,11 @@ fun main() -> Int =
 fn closure_calls_fn_param() {
     let src = format!(
         "{}{}\
-fun apply(xs: List[Int], cb: fn(Int) -> Int) -> List[Int] =
+fun apply(xs: Slice[Int], cb: fn(Int) -> Int) -> Slice[Int] =
   mapList(xs, |x| cb(x))
 fun main() -> Int =
-  reduceList(apply(List(1, 2, 3), |n| n * 10), 0, |a, b| a + b)
+  reduceList(apply(Slice(1, 2, 3), |n| n * 10), 0, |a, b| a + b)
 ",
         STD_HEAD, LIST_FNS
     );
@@ -1622,13 +1622,13 @@ fn record_of_fns_passed_explicitly() {
         "{}{}\
 record Num[T](add: fn(T, T) -> T, zero: T)
-fun sumWith(xs: List[T], num: Num[T]) -> T =
+fun sumWith(xs: Slice[T], num: Num[T]) -> T =
   reduceList(xs, num.zero, |a, b| num.add(a, b))
 fun main() -> Int =
   intNum := Num(add: |a, b| a + b, zero: 0)
   floatNum := Num(add: |a, b| a + b, zero: 0.0)
-  if sumWith(List(1, 2, 3), intNum) == 6 && sumWith(List(1.5, 2.5), floatNum) == 4.0
+  if sumWith(Slice(1, 2, 3), intNum) == 6 && sumWith(Slice(1.5, 2.5), floatNum) == 4.0
     return 1
   return 0
 ",
@@ -1811,13 +1811,13 @@ fn fn_field_nested_call_arg() {
         "{}\
 import std/Array
-record Keyed[T](items: List[T], key: fn(T) -> Int) =
+record Keyed[T](items: Slice[T], key: fn(T) -> Int) =
   fun first(self) -> Int =
     self.key(self.items.data.get(0))
 fun main() -> Int =
-  k := Keyed[Int](items: List(5, 6), key: |n| n * 8)
+  k := Keyed[Int](items: Slice(5, 6), key: |n| n * 8)
   k.first() + 2
 ",
         STD_HEAD
@@ -1830,7 +1830,7 @@ fn const_list_table() {
     let src = format!(
         "{}{}\
 primitive Tables =
-  Values = List(10, 20, 30)
+  Values = Slice(10, 20, 30)
 fun total() -> Int =
   reduceList(Tables.Values, 0, |a, b| a + b)
@@ -1886,7 +1886,7 @@ fn filter_form_no_closure() {
     let form = format!(
         "{head}\
 fun main() -> Int =
-  units := List(1, 2, 3, 4)
+  units := Slice(1, 2, 3, 4)
   alive := for u := range units.filter()
     u > 2
   alive.length()
@@ -1899,7 +1899,7 @@ fun main() -> Int =
     let closure = format!(
         "{STD_HEAD}\
 fun main() -> Int =
-  units := List(1, 2, 3, 4)
+  units := Slice(1, 2, 3, 4)
   alive := retainList(units, |u| u > 2)
   alive.length()
 {LIST_FNS}"
@@ -1927,7 +1927,7 @@ fn map_with_clauses_fused() {
     let src = format!(
         "{STD_HEAD}import std/Seq\n\
 fun main() -> Int =
-  xs := List(1, 2, 3, 4, 5, 6)
+  xs := Slice(1, 2, 3, 4, 5, 6)
   ys := for x := range xs.map(), if x % 2 == 0, sq := x * x
     sq + 1
   ys.length()
@@ -1981,7 +1981,7 @@ fn no_closure_in_expansion() {
     let src = format!(
         "{}\
 fun main() -> Int =
-  xs := List(1, 2, 3, 4, 5, 6)
+  xs := Slice(1, 2, 3, 4, 5, 6)
   total := for acc, x := range xs.fold(0), if x % 2 == 0
     acc + x
   total
@@ -2005,7 +2005,7 @@ fn seq_param_take_fused() {
     let src = format!(
         "{}\
 fun main() -> Int =
-  xs := List(1, 2, 3, 4, 5, 6)
+  xs := Slice(1, 2, 3, 4, 5, 6)
   ys := for x := range xs.take(3).map()
     x * 10
   ys.at(0) + ys.at(1) + ys.at(2) + ys.length()
@@ -2028,12 +2028,12 @@ fn pack_binder_passes_through_map() {
     // map over a two-value source: map's single name `x` holds both values and is passed to yield
     let src = format!(
         "{}\
-fun* pairs(src: List[Int]) *(Int, Int) =
+fun* pairs(src: Slice[Int]) *(Int, Int) =
   for i, x := range src
     yield i, x
 fun main() -> Int =
-  xs := List(4, 5, 6)
+  xs := Slice(4, 5, 6)
   total := 0
   for i, x := range pairs(xs).map()
     total = total + i * x
@@ -2050,14 +2050,14 @@ fn fun_star_method_no_closure() {
     // A `fun*` method is expanded at the use site: no closure, no call_indirect, `self` bound once.
     let src = format!(
         "{}\
-record Bag(items: List[Int]) =
+record Bag(items: Slice[Int]) =
   fun* doubled(self) *Int =
     for x := range self.items
       yield x * 2
 fun main() -> Int =
-  b := Bag(items: List(1, 2, 3))
+  b := Bag(items: Slice(1, 2, 3))
   total := 0
   for d := range b.doubled()
     total = total + d
@@ -2099,7 +2099,7 @@ fn seq_chain_take_filter_fused() {
     let src = format!(
         "{}\
 fun main() -> Int =
-  xs := List(1, 2, 3, 4, 5, 6, 7, 8)
+  xs := Slice(1, 2, 3, 4, 5, 6, 7, 8)
   got := for x := range xs.take(6).filter()
     x % 2 == 0
   got.length()
@@ -2122,7 +2122,7 @@ fn terminal_mid_chain_error() {
     let src = format!(
         "{}\
 fun main() -> Int =
-  xs := List(1, 2, 3)
+  xs := Slice(1, 2, 3)
   got := for x := range xs.filter().take(2)
     x
   0
@@ -2141,7 +2141,7 @@ fn seq_cannot_be_stored() {
     let src = format!(
         "{}\
 fun main() -> Int =
-  xs := List(1, 2, 3)
+  xs := Slice(1, 2, 3)
   s := xs.take(2)
   0
 ",
@@ -2407,13 +2407,13 @@ fn bang_message_names_the_file_of_the_callee_fn() {
 import std/Str
 import std/Int
 import std/Float
-import std/List
+import std/Slice
-fun first(xs: List[Int]) -> Int =
+fun first(xs: Slice[Int]) -> Int =
   xs.first()!
 fun main() -> Int =
-  first(List[Int]())
+  first(Slice[Int]())
 ";
     let (r, msgs) = runWithCrash("bangfile", src);
     assert!(r.is_err());
@@ -2491,20 +2491,20 @@ fn list_of_error_unions_across_sets_valid_wasm() {
 import std/Str
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 fun chk(n: Int) -> !Int =
   if n < 0
     return error.Neg
   n
-fun total(xs: List[error{Neg}!Int]) -> Int =
+fun total(xs: Slice[error{Neg}!Int]) -> Int =
   a := xs.at(0) catch 0
   b := xs.at(1) catch 100
   a + b
 fun main() -> Int =
-  xs := List(chk(4))
+  xs := Slice(chk(4))
   xs.push(chk(-1))
   total(xs)
 ";

plum-wasm-codegen/tests/enum_init_e2e_test.rs ADDED Viewed

@@ -0,0 +1,148 @@
+#![allow(non_snake_case)]
+use plum_wasm_codegen::compileSource;
+fn gcEngine() -> wasmtime::Engine {
+    let mut config = wasmtime::Config::new();
+    config.wasm_gc(true);
+    config.wasm_function_references(true);
+    wasmtime::Engine::new(&config).expect("engine with GC config should construct")
+}
+fn repoRoot() -> std::path::PathBuf {
+    std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("..")
+}
+fn load(name: &str, src: &str) -> Result<plum_core::ast::Source, String> {
+    let dir = std::env::temp_dir().join(format!("plum_enum_init_{}_{}", name, std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("main.plum");
+    std::fs::write(&path, src).unwrap();
+    let r = plum_core::loadAndMerge(&path, &repoRoot());
+    let _ = std::fs::remove_dir_all(&dir);
+    r.map_err(|e| format!("{e}"))
+}
+/// Compiles `src` through the real pipeline and runs its `main() -> Int`.
+fn runInt(name: &str, src: &str) -> i64 {
+    let source = load(name, src).expect("load");
+    let bytes = compileSource(&source).unwrap_or_else(|e| panic!("compile failed: {e}"));
+    wasmparser::validate(&bytes).expect("valid wasm");
+    let engine = gcEngine();
+    let module = wasmtime::Module::new(&engine, &bytes).unwrap();
+    let mut store = wasmtime::Store::new(&engine, ());
+    let mut linker = wasmtime::Linker::new(&engine);
+    linker
+        .define_unknown_imports_as_default_values(&mut store, &module)
+        .unwrap();
+    let instance = linker.instantiate(&mut store, &module).unwrap();
+    let main = instance
+        .get_typed_func::<(), i64>(&mut store, "main")
+        .unwrap();
+    main.call(&mut store, ()).unwrap()
+}
+const LINK: &str = "enum Link[T] =
+  | Nil
+  | Cons(head: T, tail: Link[T])
+  fun init(values: ...T) -> Link[T] =
+    out: Link[T] := Nil
+    i := values.length() - 1
+    while i >= 0
+      out = Cons(head: values.at(i), tail: out)
+      i = i - 1
+    out
+  fun length(self) -> Int = match self
+    Nil => 0
+    Cons(_, t) => 1 + t.length()
+  fun sum(self) -> Int = match self
+    Nil => 0
+    Cons(h, t) => h + t.sum()
+";
+fn prog(body: &str) -> String {
+    format!("import std/Str\nimport std/Int\n\n{body}")
+}
+#[test]
+fn variadic_init_builds_list() {
+    let src = prog(&format!("{LINK}fun main() -> Int =
+  xs := Link(1, 2, 3, 4)
+  xs.sum() * 10 + xs.length()
+"));
+    assert_eq!(runInt("variadic", &src), 104);
+}
+#[test]
+fn empty_init_with_annotation() {
+    let src = prog(&format!("{LINK}fun main() -> Int =
+  xs: Link[Int] := Link()
+  xs.length() + 7
+"));
+    assert_eq!(runInt("empty", &src), 7);
+}
+#[test]
+fn fixed_param_init() {
+    let src = prog("enum Pair2 =
+  | Zero
+  | Two(a: Int, b: Int)
+  fun init(a: Int, b: Int) -> Pair2 = Two(a: a, b: b)
+  fun total(self) -> Int = match self
+    Zero => 0
+    Two(a, b) => a + b
+fun main() -> Int =
+  Pair2(3, 4).total()
+");
+    assert_eq!(runInt("fixed", &src), 7);
+}
+#[test]
+fn no_init_error_message() {
+    let src = prog("enum Shape =
+  | Dot
+  | Sq(side: Int)
+fun main() -> Int =
+  s := Shape(1)
+  0
+");
+    let err = match load("noinit", &src) {
+        Err(e) => e,
+        Ok(source) => match compileSource(&source) {
+            Err(e) => e,
+            Ok(_) => panic!("expected error"),
+        },
+    };
+    assert!(
+        err.contains("Shape has no init; construct a variant or declare `fun init`"),
+        "{err}"
+    );
+}
+#[test]
+fn variant_name_wins() {
+    let src = prog(&format!("{LINK}fun main() -> Int =
+  xs := Cons(head: 5, tail: Link(1, 2))
+  xs.sum() * 10 + xs.length()
+"));
+    assert_eq!(runInt("variantwins", &src), 83);
+}
+#[test]
+fn generic_inferred_from_args() {
+    let src = prog(&format!("{LINK}fun total(xs: Link[Int]) -> Int = xs.sum()
+fun main() -> Int =
+  total(Link(5, 6)) + Link(\"a\", \"b\").length()
+"));
+    assert_eq!(runInt("infer", &src), 13);
+}

plum-wasm-codegen/tests/examples_test.rs CHANGED Viewed

@@ -98,7 +98,7 @@ fn ioExampleCompilesAndRunsCorrectly() {
     // `io.plum` now also transitively pulls in `rawRandomHalf` (via the
     // always-implicit `std/str` prelude — `str` -> `list` -> `int`, which
-    // declares it for `List.sample`/`shuffle` — see
+    // declares it for `Slice.sample`/`shuffle` — see
     // `plum-core::loader::loadAndMerge`), even though this test never
     // actually calls anything that uses it. Wire up a harmless stub so the
     // module can still instantiate; every import must be satisfied in
@@ -205,7 +205,7 @@ fn array_int_native() {
 #[test]
 fn const_table_1000_entries() {
     let mut src = String::from(
-        "module t\nimport std/Int\nimport std/Float\nimport std/List\n\nprimitive Table =\n",
+        "module t\nimport std/Int\nimport std/Float\nimport std/Slice\n\nprimitive Table =\n",
     );
     for i in 0..500 {
         src.push_str(&format!("  E{} = {}\n", i, i * 3 + 1));
@@ -216,7 +216,7 @@ fn const_table_1000_entries() {
         src.push_str(&format!("  E{} = {}\n", i, i * 3 + 1));
     }
     src.push_str(
-        "  Flag = true\n  Double = Table.E0 * 2 + 1\n\nfun table() -> List[Int] =\n  return List(",
+        "  Flag = true\n  Double = Table.E0 * 2 + 1\n\nfun table() -> Slice[Int] =\n  return Slice(",
     );
     let items: Vec<String> = (0..1000).map(|i| (i * i).to_string()).collect();
     src.push_str(&items.join(", "));

plum-wasm-codegen/tests/inline_variants_e2e_test.rs CHANGED Viewed

@@ -52,7 +52,7 @@ fn checkErrors(name: &str, src: &str) -> Vec<String> {
 const HEAD: &str = "\
 import std/Str
 import std/Int
-import std/List
+import std/Slice
 enum Link[T] = Nil | Cons(head: T, tail: Link[T])

plum-wasm-codegen/tests/loop_break_e2e_test.rs CHANGED Viewed

@@ -44,7 +44,7 @@ fn runInt(name: &str, src: &str) -> i64 {
     main.call(&mut store, ()).unwrap()
 }
-const PRE: &str = "import std/Str\nimport std/Int\nimport std/Float\nimport std/List\n\n";
+const PRE: &str = "import std/Str\nimport std/Int\nimport std/Float\nimport std/Slice\n\n";
 fn prog(body: &str) -> String {
     format!("{PRE}{body}")

plum-wasm-codegen/tests/own_inplace_e2e_test.rs CHANGED Viewed

@@ -61,7 +61,7 @@ fn structNewCount(name: &str, src: &str) -> usize {
     n
 }
-const PRE: &str = "import std/Str\nimport std/Int\nimport std/Float\nimport std/List\n\n";
+const PRE: &str = "import std/Str\nimport std/Int\nimport std/Float\nimport std/Slice\n\n";
 fn prog(body: &str) -> String {
     format!("{PRE}{body}")

plum-wasm-codegen/tests/record_embed_e2e_test.rs CHANGED Viewed

@@ -42,7 +42,7 @@ fn runInt(name: &str, src: &str) -> i64 {
 }
-const PRE: &str = "import std/Str\nimport std/Int\nimport std/Float\nimport std/List\n\n";
+const PRE: &str = "import std/Str\nimport std/Int\nimport std/Float\nimport std/Slice\n\n";
 fn prog(body: &str) -> String {
     format!("{PRE}{body}")

plum-wasm-codegen/tests/record_init_e2e_test.rs CHANGED Viewed

@@ -42,17 +42,17 @@ fn runInt(name: &str, src: &str) -> i64 {
 }
-const PRE: &str = "import std/Str\nimport std/Int\nimport std/Float\nimport std/List\n\n";
+const PRE: &str = "import std/Str\nimport std/Int\nimport std/Float\nimport std/Slice\n\n";
 fn prog(body: &str) -> String {
     format!("{PRE}{body}")
 }
-const ACTOR: &str = "trait Actor(px: Int, py: Int, width: Int, height: Int, kids: List[Int]) =
+const ACTOR: &str = "trait Actor(px: Int, py: Int, width: Int, height: Int, kids: Slice[Int]) =
   fun init(self) =
     self.width = 10
     self.height = self.width * 2
-    self.kids = List[Int]()
+    self.kids = Slice[Int]()
   fun area(self) -> Int = self.width * self.height
 ";

plum-wasm-codegen/tests/tail_calls_e2e_test.rs CHANGED Viewed

@@ -44,7 +44,7 @@ fn runInt(name: &str, src: &str) -> i64 {
     main.call(&mut store, ()).unwrap()
 }
-const PRE: &str = "import std/Str\nimport std/Int\nimport std/Float\nimport std/List\n\n";
+const PRE: &str = "import std/Str\nimport std/Int\nimport std/Float\nimport std/Slice\n\n";
 fn prog(body: &str) -> String {
     format!("{PRE}{body}")

plum-wasm-codegen/tests/traits_e2e_test.rs CHANGED Viewed

@@ -42,7 +42,7 @@ fn runInt(name: &str, src: &str) -> i64 {
 }
-const PRE: &str = "import std/Str\nimport std/Int\nimport std/Float\nimport std/List\n\n";
+const PRE: &str = "import std/Str\nimport std/Int\nimport std/Float\nimport std/Slice\n\n";
 fn prog(body: &str) -> String {
     format!("{PRE}{body}")
@@ -74,7 +74,7 @@ record Tree(Entity(pos, z), age: Int) =
 fun main() -> Int =
   h := House(pos: Vec2(x: 1, y: 2), z: 0, hits: 0, kind: 3)
-  es: List[Entity] := List[Entity]()
+  es: Slice[Entity] := Slice[Entity]()
   es.push(h)
   es.push(Tree(pos: Vec2(x: 5, y: 5), z: 1, age: 10))
   total := 0
@@ -102,7 +102,7 @@ record Ci(Shape(n), r: Int) =
   override fun draw(self) -> Int = self.r + 1
 fun main() -> Int =
-  xs: List[Shape] := List[Shape]()
+  xs: Slice[Shape] := Slice[Shape]()
   xs.push(Sq(n: 0, s: 5))
   xs.push(Ci(n: 0, r: 20))
   xs.at(0).twice() * 1000 + xs.at(1).twice()
@@ -113,7 +113,7 @@ fun main() -> Int =
 #[test]
 fn three_level_actor_tree() {
     let src = prog("\
-trait Actor(children: List[Actor], v: Int) =
+trait Actor(children: Slice[Actor], v: Int) =
   fun own(self) -> Int
   fun total(self) -> Int =
     sum := self.own()
@@ -131,15 +131,15 @@ record Leaf(Actor(children, v)) =
   override fun own(self) -> Int = self.v
 fun main() -> Int =
-  l1 := Leaf(children: List[Actor](), v: 100)
+  l1 := Leaf(children: Slice[Actor](), v: 100)
-  l2 := Leaf(children: List[Actor](), v: 200)
+  l2 := Leaf(children: Slice[Actor](), v: 200)
-  mk: List[Actor] := List[Actor]()
+  mk: Slice[Actor] := Slice[Actor]()
   mk.push(l1)
   mk.push(l2)
   m := Mid(children: mk, v: 0, w: 10)
-  rk: List[Actor] := List[Actor]()
+  rk: Slice[Actor] := Slice[Actor]()
   rk.push(m)
-  rk.push(Leaf(children: List[Actor](), v: 1000))
+  rk.push(Leaf(children: Slice[Actor](), v: 1000))
   r := Root(children: rk, v: 0)
   r.total()
 ");
@@ -355,7 +355,7 @@ fun main() -> Int =
 #[test]
 fn subtyped_with_boxed_second_self_list_and_eq() {
     let src = prog("\
-trait Actor(x: Int, kids: List[Actor]) =
+trait Actor(x: Int, kids: Slice[Actor]) =
   fun hit(self) -> Int
 trait Extra(n: Int) =
@@ -366,7 +366,7 @@ record Dot(Actor(x, kids), Extra(n), w: Int) =
   override fun b(self) -> Int = self.n
 fun main() -> Int =
-  d := Dot(x: 1, kids: List[Actor](), n: 6, w: 3)
+  d := Dot(x: 1, kids: Slice[Actor](), n: 6, w: 3)
   a: Actor := d
   e: Extra := d
   e.n = 8

plum-wasm-codegen/tests/type_param_static_test.rs CHANGED Viewed

@@ -99,19 +99,19 @@ fun main() -> Int =
 fn nested_generic() {
     let src = "\
 import std/Int
-import std/List
+import std/Slice
 record Pt(x: Int) =
   fun make(n: Int) -> Pt = Pt(x: n + 1)
-fun buildAll(ns: List[Int]) -> List[T] =
+fun buildAll(ns: Slice[Int]) -> Slice[T] =
-  out := List[T]()
+  out := Slice[T]()
   for n := range ns
     out.push(T.make(n))
   return out
 fun main() -> Int =
-  ps: List[Pt] := buildAll(List(1, 2, 3))
+  ps: Slice[Pt] := buildAll(Slice(1, 2, 3))
   p := ps.get(2) catch e
     return 0
   return p.x
@@ -142,10 +142,10 @@ fun main() -> Int =
 #[test]
 fn extension_outside_std_is_rejected() {
     let src = "\
-import std/List
+import std/Slice
 import std/Int
-primitive List[T] =
+primitive Slice[T] =
   fun extra(self) -> Int = 1
 fun main() -> Int = 0

plum-wasm-codegen/tests/unboxed_variants_e2e_test.rs ADDED Viewed

@@ -0,0 +1,252 @@
+#![allow(non_snake_case)]
+//! Unboxed layout: union-enum members and inline variants are wasm-gc subtypes
+//! of the enum, so constructing one allocates exactly one struct.
+use plum_wasm_codegen::compileSource;
+use wasmparser::{Operator, Parser, Payload};
+fn repoRoot() -> std::path::PathBuf {
+    std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("..")
+}
+fn compile(name: &str, src: &str) -> Vec<u8> {
+    let dir = std::env::temp_dir().join(format!("plum_unboxed_{}_{}", name, std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("main.plum");
+    std::fs::write(&path, src).unwrap();
+    let r = plum_core::loadAndMerge(&path, &repoRoot());
+    let _ = std::fs::remove_dir_all(&dir);
+    let source = r.unwrap_or_else(|e| panic!("load failed: {e}"));
+    let bytes = compileSource(&source).unwrap_or_else(|e| panic!("compile failed: {e}"));
+    wasmparser::validate(&bytes).expect("valid wasm");
+    bytes
+}
+/// Number of `struct.new` instructions in the exported `main` function.
+fn structNewsInMain(bytes: &[u8]) -> usize {
+    let mut imports = 0u32;
+    let mut mainIdx = None;
+    let mut bodies = Vec::new();
+    for p in Parser::new(0).parse_all(bytes) {
+        match p.unwrap() {
+            Payload::ImportSection(s) => {
+                for i in s {
+                    if matches!(i.unwrap().ty, wasmparser::TypeRef::Func(_)) {
+                        imports += 1;
+                    }
+                }
+            }
+            Payload::ExportSection(s) => {
+                for e in s {
+                    let e = e.unwrap();
+                    if e.name == "main" {
+                        mainIdx = Some(e.index);
+                    }
+                }
+            }
+            Payload::CodeSectionEntry(b) => bodies.push(b),
+            _ => {}
+        }
+    }
+    let body = &bodies[(mainIdx.expect("main export") - imports) as usize];
+    let mut n = 0;
+    let mut r = body.get_operators_reader().unwrap();
+    while !r.eof() {
+        if matches!(r.read().unwrap(), Operator::StructNew { .. }) {
+            n += 1;
+        }
+    }
+    n
+}
+fn runInt(name: &str, src: &str) -> i64 {
+    let bytes = compile(name, src);
+    let mut config = wasmtime::Config::new();
+    config.wasm_gc(true);
+    config.wasm_function_references(true);
+    let engine = wasmtime::Engine::new(&config).expect("engine");
+    let module = wasmtime::Module::new(&engine, &bytes).unwrap();
+    let mut store = wasmtime::Store::new(&engine, ());
+    let mut linker = wasmtime::Linker::new(&engine);
+    linker
+        .define_unknown_imports_as_default_values(&mut store, &module)
+        .unwrap();
+    let instance = linker.instantiate(&mut store, &module).unwrap();
+    let main = instance
+        .get_typed_func::<(), i64>(&mut store, "main")
+        .unwrap();
+    main.call(&mut store, ()).unwrap()
+}
+const HEAD: &str = "\
+import std/Str
+import std/Int
+import std/Float
+";
+#[test]
+fn cons_one_struct_new() {
+    let src = format!(
+        "{HEAD}\
+enum Link[T] = End | Pair(head: T, tail: Link[T])
+fun main() -> Int =
+  xs: Link[Int] := Pair(head: 1, tail: End)
+  1
+"
+    );
+    assert_eq!(structNewsInMain(&compile("cons1", &src)), 1);
+}
+#[test]
+fn union_member_one_struct_new() {
+    let src = format!(
+        "{HEAD}\
+record Circle(r: Float)
+record Rect(w: Float, h: Float)
+enum Shape = Circle | Rect
+fun main() -> Int =
+  s: Shape := Circle(r: 2.0)
+  t: Shape := Rect(w: 1.0, h: 2.0)
+  1
+"
+    );
+    assert_eq!(structNewsInMain(&compile("union1", &src)), 2);
+}
+#[test]
+fn generic_link_instantiations_separate() {
+    let src = format!(
+        "{HEAD}\
+enum Link[T] = End | Pair(head: T, tail: Link[T])
+fun main() -> Int =
+  a: Link[Int] := Pair(head: 1, tail: End)
+  b: Link[Int] := Pair(head: 2, tail: a)
+  c: Link[Float] := Pair(head: 1.5, tail: End)
+  1
+"
+    );
+    assert_eq!(structNewsInMain(&compile("generic", &src)), 3);
+}
+#[test]
+fn own_record_member_ok() {
+    let src = format!(
+        "{HEAD}\
+own record Node(v: Int)
+record Leaf(v: Int)
+enum Tree = Node | Leaf
+fun main() -> Int =
+  t: Tree := Node(v: 3)
+  1
+"
+    );
+    assert_eq!(structNewsInMain(&compile("own", &src)), 1);
+}
+#[test]
+fn match_member_fields() {
+    let src = format!(
+        "{HEAD}\
+record Circle(r: Int)
+record Rect(w: Int, h: Int)
+enum Shape = Circle | Rect
+fun area(s: Shape) -> Int =
+  match s
+    Circle(r) => r * r
+    Rect(w, h) => w * h
+fun main() -> Int =
+  area(Circle(r: 3)) * 100 + area(Rect(w: 2, h: 5))
+"
+    );
+    assert_eq!(runInt("match_fields", &src), 910);
+}
+#[test]
+fn nested_enum_match() {
+    let src = format!(
+        "{HEAD}\
+enum Link[T] = End | Pair(head: T, tail: Link[T])
+fun sum(l: Link[Int]) -> Int =
+  match l
+    End => 0
+    Pair(head, tail) => head + sum(tail)
+fun second(l: Link[Int]) -> Int =
+  match l
+    Pair(_, Pair(h, _)) => h
+    _ => -1
+fun main() -> Int =
+  l: Link[Int] := Pair(head: 1, tail: Pair(head: 20, tail: Pair(head: 300, tail: End)))
+  sum(l) * 1000 + second(l)
+"
+    );
+    assert_eq!(runInt("nested", &src), 321020);
+}
+#[test]
+fn equality_and_toStr() {
+    let src = format!(
+        "{HEAD}\
+record Circle(r: Int) =
+  fun toStr(self) -> Str = \"Circle\"
+record Rect(w: Int, h: Int) =
+  fun toStr(self) -> Str = \"Rect\"
+enum Shape = Circle | Rect
+fun main() -> Int =
+  a: Shape := Circle(r: 2)
+  b: Shape := a
+  c: Shape := Rect(w: 1, h: 2)
+  x := if a == b then 1 else 0
+  y := if a != c then 10 else 0
+  z := if c.toStr() == \"Rect\" then 100 else 0
+  x + y + z
+"
+    );
+    assert_eq!(runInt("eq_tostr", &src), 111);
+}
+#[test]
+fn json_round_trip_union() {
+    let src = format!(
+        "{HEAD}\
+import std/Json
+record Circle(r: Int) =
+  fun toJson(self) -> Json = Json.object(\"r\" => self.r.toJson())
+  fun fromJson(j: Json) -> JsonError!Circle =
+    return Circle(r: try Int.fromJson(try j.field(\"r\")))
+record Rect(w: Int, h: Int) =
+  fun toJson(self) -> Json = Json.object(\"w\" => self.w.toJson(), \"h\" => self.h.toJson())
+  fun fromJson(j: Json) -> JsonError!Rect =
+    return Rect(w: try Int.fromJson(try j.field(\"w\")), h: try Int.fromJson(try j.field(\"h\")))
+enum Shape = Circle | Rect
+fun main() -> Int =
+  a: Shape := Circle(r: 7)
+  b: Shape := Rect(w: 3, h: 4)
+  ja := Json.encode(a)
+  jb := Json.encode(b)
+  a2: JsonError!Circle := Json.decode(ja)
+  b2: JsonError!Rect := Json.decode(jb)
+  s2: Shape := b2!
+  ok := Json.encode(a2!) == ja && Json.encode(s2) == jb
+  if ok then 1 else 0
+"
+    );
+    assert_eq!(runInt("json_union", &src), 1);
+}

plum-wasm-codegen/tests/unions_e2e_test.rs CHANGED Viewed

@@ -53,7 +53,7 @@ const DEFS: &str = "\
 import std/Str
 import std/Int
 import std/Float
-import std/List
+import std/Slice
 struct Circle(r: Float) =
   fun area(self) -> Float = self.r * self.r * 3.0
@@ -90,8 +90,8 @@ fun main() -> Int =
 ",
     );
     let src = src.replace(
-        "import std/List\n",
+        "import std/Slice\n",
-        "import std/List\n\nerror ParseError = Bad | Worse\n",
+        "import std/Slice\n\nerror ParseError = Bad | Worse\n",
     );
     assert_eq!(runInt("optional", &src), 19);
 }
@@ -100,10 +100,10 @@ fun main() -> Int =
 fn invariant_list_rejected() {
     let src = withDefs(
         "\
-fun take(xs: List[Shape]) -> Int =
+fun take(xs: Slice[Shape]) -> Int =
   1
-fun go(cs: List[Circle]) -> Int =
+fun go(cs: Slice[Circle]) -> Int =
   take(cs)
 ",
     );