6203667 | plum | pyrossh

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

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

6203667 — Peter John 2026-11-04T13:09:59+05:30

examples: consolidate 39 files into 25 topical ones (tests unchanged: 408); assets and tools move under games/

Files changed (39) hide show

plum-examples/annotated_locals.plum +0 -78
plum-examples/{struct_arrays.plum → arrays.plum} +54 -6
plum-examples/basics.plum +115 -2
plum-examples/cons_list.plum +0 -70
plum-examples/constants.plum +0 -72
plum-examples/control_flow.plum +133 -1
plum-examples/digit_names.plum +0 -59
plum-examples/{error_propagation.plum → errors.plum} +238 -0
plum-examples/forms.plum +0 -155
plum-examples/functions.plum +0 -77
plum-examples/{assets → games/assets}/gameover.wav +0 -0
plum-examples/{assets → games/assets}/hit.wav +0 -0
plum-examples/{assets → games/assets}/music.wav +0 -0
plum-examples/{assets → games/assets}/pickup.wav +0 -0
plum-examples/{assets → games/assets}/sprites.png +0 -0
plum-examples/games/functional/game_state_view.plum +450 -549
plum-examples/games/imperative/game.plum +43 -23
plum-examples/{game_loop.plum → games/imperative/game_loop.plum} +1 -1
plum-examples/games/imperative/game_scene.plum +51 -47
plum-examples/games/imperative/scene.plum +7 -8
plum-examples/games/pure/game_pure_scene.plum +181 -163
plum-examples/{tools → games/tools}/make_sounds.py +1 -1
plum-examples/{tools → games/tools}/make_sprites.py +0 -0
plum-examples/io.plum +0 -14
plum-examples/loops.plum +0 -125
plum-examples/numbers.plum +142 -0
plum-examples/operators.plum +0 -67
plum-examples/optionals.plum +0 -232
plum-examples/own_list.plum +0 -33
plum-examples/recursion.plum +221 -0
plum-examples/{seq.plum → sequences.plum} +161 -2
plum-examples/struct_union_members.plum +1 -1
plum-examples/structs_records.plum +156 -12
plum-examples/tail_calls.plum +0 -110
plum-examples/testing.plum +0 -20
plum-examples/trait_scene.plum +0 -50
plum-examples/traits.plum +62 -6
plum-examples/typed_arrays.plum +0 -39
plum-examples/unboxed_variants.plum +6 -6

plum-examples/annotated_locals.plum DELETED Viewed

@@ -1,78 +0,0 @@
-# Annotated local declarations: `name: Type := value` fixes the local's type to
-# the annotation. The value converts to it exactly as it would for a parameter of
-# that type (a union member into its enum, `T` into `T?`, `null` into `T?`), and
-# a later `name = value` is checked and converted against the same type.
-module annotated_locals
-import std/Str
-import std/Int
-import std/Float
-import std/Slice
-record Circle(r: Float)
-record Rect(w: Float, h: Float)
-enum Shape = Circle | Rect
-error LocalError = Bad | Worse
-fun area(s: Shape) -> Float =
-  match s
-    Circle(r) => r * r * 3.0
-    Rect(w, h) => w * h
-fun parseLocal(n: Int) -> LocalError!Int =
-  if n < 0
-    return error.Bad
-  n * 2
-fun twice(x: Int) -> Int = x * 2
-fun same(x: T) -> T =
-  y: T := x
-  y
-test "union_local"
-  s: Shape := Circle(r: 2.0)
-  assert area(s) == 12.0
-test "union_local_reassigned"
-  s: Shape := Circle(r: 1.0)
-  s = Rect(w: 2.0, h: 3.0)
-  assert area(s) == 6.0
-test "optional_local_present"
-  o: Int? := 4
-  assert {o ?: 0} == 4
-test "optional_local_null"
-  o: Int? := null
-  assert {o ?: 9} == 9
-  o = 5
-  assert {o ?: 9} == 5
-test "list_local"
-  xs: Slice[Shape] := Slice[Shape]()
-  xs.push(Circle(r: 1.0))
-  xs.push(Rect(w: 1.0, h: 1.0))
-  assert xs.length() == 2
-test "fn_local"
-  f: fn(Int) -> Int := twice
-  assert f(4) == 8
-test "scalar_locals"
-  n: Int := 3
-  x: Float := 2.5
-  assert n + 1 == 4
-  assert x * 2.0 == 5.0
-test "generic_param_annotation"
-  assert same(7) == 7
-  assert same("a") == "a"
-test "named_error_set_local"
-  ok: LocalError!Int := parseLocal(4)
-  bad: LocalError!Int := parseLocal(-1)
-  assert {ok catch 0} == 8
-  assert {bad catch 7} == 7

plum-examples/{struct_arrays.plum → arrays.plum} RENAMED Viewed

@@ -1,13 +1,48 @@
-# Arrays of structs are stored field by field (struct-of-arrays): `Array[Vec2]`
+# Arrays: typed native arrays and arrays of structs.
-# is one object holding an `f64` array for `x` and one for `y`, so `get`/`set`
-# 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/Slice
 import std/Grid
+import std/Seq
+import std/Str
+import std/Slice
+# ==== typed arrays ====
+# Typed arrays: unboxed native `Array[Int]` and `Array[Float]` lowering to
+# WebAssembly primitive arrays, along with flat 2D `Grid[T]`.
+# Tile-grid style data: Array[Int] / Array[Float] / Array[Bool] are native
+# unboxed wasm arrays (i64 / f64 / i32 elements), not boxed anyref arrays.
+fun sumInts(n: Int) -> Int =
+  a := Array.filled(n, 3)
+  total := 0
+  for i := range n
+    total = total + a.get(i)
+  return total
+fun sumFloats(n: Int) -> Float =
+  a := Array.filled(n, 0.5)
+  total := 0.0
+  for i := range n
+    total = total + a.get(i)
+  return total
+fun countTrue(n: Int) -> Int =
+  a := Array.filled(n, false)
+  a.set(1, true)
+  a.set(3, true)
+  c := 0
+  for i := range n
+    if a.get(i)
+      c = c + 1
+  return c
+# ==== struct arrays ====
+# 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. `Slice`, `Grid` and friends get this for free.
 struct Vec2(x: Float, y: Float)
@@ -21,9 +56,13 @@ struct Tile(id: Int, solid: Bool, weight: Float)
 record World(points: Slice[Vec2], name: Str)
 struct One(n: Int)
 struct Flags(a: Bool, b: Bool, c: Int)
 struct L3(r: Rect, k: Int)
 record Holder(arr: Array[Vec2])
 record Named(label: Str, v: Vec2)
 fun bump(h: Holder) =
@@ -40,6 +79,15 @@ struct Px(r: Byte, g: Byte, b: Byte, a: Byte)
 fun mkPx(v: Int) -> Px =
   Px(r: Byte(v), g: Byte(v + 1), b: Byte(v + 2), a: Byte(255))
+# ==== typed arrays tests ====
+test "array_int_native: filled arrays hold their values"
+  assert sumInts(10) == 30
+  assert sumFloats(4) == 2.0
+  assert countTrue(5) == 2
+# ==== struct arrays tests ====
 test "List[Vec2] push/get/set round-trips across growth"
   l := Slice[Vec2]()
   for i := range 100

plum-examples/basics.plum CHANGED Viewed

@@ -1,7 +1,10 @@
-module basics
+# Basics: literals, operators, functions, testing and the Io entry point.
 import std/Int
 import std/Float
 import std/Str
+import std/Io
+# ==== basics ====
 # A `primitive` with a non-built-in name is a stateless namespace: constants and
 # static functions, reached as `Config.MaxRetries`. It is not a value or a type.
@@ -10,7 +13,7 @@ primitive Config =
   GoldenRatio = 1.61803
   Greeting = "hello"
-fun main() =
+fun syntaxTour() =
   dec := 42
   hex := 0xFF
   bin := 0b1010
@@ -31,3 +34,113 @@ fun main() =
   positive := +sum
   inverted := !cmp
   a, b := 1, 2
+# ==== io ====
+# Every call that leaves the program goes through the `Io` capability. An entry
+# point (`main`, an `export fun`, a `test`) may take it as its first parameter.
+fun main(io: Io) =
+  io.printLn("hello from plum")
+  name := "world"
+  io.printLn("hello, {name}!")
+# ==== testing ====
+# Testing: native `test "name"` blocks and `assert` statements executed by
+# the `plum test` runner.
+fun add(a: Int, b: Int) -> Int =
+  a + b
+fun isEven(n: Int) -> Bool =
+  n % 2 == 0
+# ==== functions ====
+# Functions: top-level function declarations, typed arguments, default and
+# variadic parameters, return expressions, and recursion.
+fun addInts(a: Int, b: Int) -> Int =
+  a + b
+fun greet() =
+  todo
+fun withDefault(a: Int, step: Int = 1) -> Int =
+  a + step
+fun sumAll(nums: ...Int) -> Int =
+  total := 0
+  for v := range nums
+    total = total + v
+  total
+fun wrap(value: T) -> Bool =
+  true
+fun pair(first: T, second: U) -> Bool =
+  true
+fun useWrap() -> Bool =
+  wrap(5)
+fun usePair() -> Bool =
+  pair(1, "x")
+# ---- recursion, defaults and variadics ----
+fun factorial(x: Int) -> Int =
+  if x < 2
+    return 1
+  return x * factorial(x - 1)
+# Regression test: `double(...)` (an all-lowercase, no-uppercase, no-underscore
+# callee) used to fail to parse at all — `var_identifier` and `fn_identifier`
+# both matched its text and the grammar's lexer would nondeterministically
+# commit to `var_identifier`, breaking every such call site.
+fun double(n: Int) -> Int =
+  n * 2
+fun combineVariadic(prefix: Int, rest: ...Int) -> Int =
+  prefix
+fun weighted(nums: ...Int) -> Int =
+  total := 0
+  for i, v := range nums
+    total = total + i * v
+  total
+# ==== testing tests ====
+test "add works"
+  assert add(1, 2) == 3
+  assert add(2, 2) == 4
+test "isEven works"
+  assert isEven(4)
+  assert !isEven(3)
+  assert isEven(2)
+# ==== functions tests ====
+test "factorial runs correctly"
+  assert factorial(5) == 120
+test "lowercase single word function call runs correctly"
+  assert double(21) == 42
+test "variadic call with varying trailing arg counts runs correctly"
+  a := combineVariadic(10)
+  b := combineVariadic(20, 1)
+  c := combineVariadic(30, 1, 2, 3)
+  assert a + b + c == 60
+test "sum all variadic int runs correctly"
+  assert sumAll(1, 2, 3, 4) == 10
+test "sum all variadic int with zero args runs correctly"
+  assert sumAll() == 0
+test "for over a variadic binds index and element"
+  assert weighted() == 0
+  assert weighted(5, 10, 20) == 50

plum-examples/cons_list.plum DELETED Viewed

@@ -1,70 +0,0 @@
-# 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 DELETED Viewed

@@ -1,72 +0,0 @@
-module constants
-import std/Int
-import std/Float
-import std/Str
-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
-# associated constant, a `fun` without `self` a static function. They are
-# reached as `Type.Name` / `Type.f()` from anywhere, including inside the same
-# body. Constant names are unique per type, not global.
-# A `primitive` whose name is not a built-in type is a stateless namespace.
-primitive Grid =
-  Width = 8
-  Height = Grid.Width * 2
-  CellScale = 2.5
-  Name = "plum"
-  DebugDraw = true
-  fun cells() -> Int =
-    Grid.Width * Grid.Height
-record Tile(x: Int) =
-  Width = 100
-  fun offset(self) -> Int = Tile.Width + self.x
-  fun origin() -> Tile =
-    Tile(x: 0)
-record Wrap[T](v: T) =
-  fun area(self) -> Int = Grid.Width * Grid.Height
-struct Vec2(x: Float, y: Float) =
-  Zero = Vec2(x: 0.0, y: 0.0)
-fun scaled(n: Float) -> Float = n * Grid.CellScale
-primitive Shelf =
-  Sides = 4
-  Names = Slice("a", "b", "c")
-  fun sidesTwice() -> Int =
-    twice(Shelf.Sides)
-  fun twice(n: Int) -> Int =
-    n * 2
-test "consts are usable in fns, methods, generics and derived consts"
-  assert Grid.Height == 16
-  assert Grid.cells() == 128
-  assert Tile(x: 1).offset() == 101
-  assert Wrap(v: 3.5).area() == 128
-  assert scaled(2.0) == 5.0
-  assert Grid.Name == "plum"
-  assert Grid.DebugDraw
-test "the same const name can live on two types"
-  assert Grid.Width == 8
-  assert Tile.Width == 100
-test "a struct can hold a constant instance of itself"
-  assert Vec2.Zero.x == 0.0
-  assert Tile.origin().x == 0
-test "a primitive holds a list constant and a static fn reading a sibling const"
-  assert Shelf.Names.length() == 3
-  assert Shelf.sidesTwice() == 8

plum-examples/control_flow.plum CHANGED Viewed

@@ -1,8 +1,15 @@
-# Control flow: `if`/`else` branching, `while` loops, and `for ... := range` iteration.
+# Control flow: branching and loops.
 import std/Str
 import std/Int
 import std/Float
 import std/Seq
+import std/Slice
+import std/Array
+import std/Testing
+# ==== control flow ====
+# Control flow: `if`/`else` branching, `while` loops, and `for ... := range` iteration.
 fun loopSum(limit: Int) -> Int =
   total := 0
@@ -74,6 +81,25 @@ fun checkPositiveAndReturn(n: Int) -> Int =
   assert n > 0
   n
+# ==== loops ====
+# Loops: `while` condition loops, `for ... := range` iteration over ranges and
+# collections, with inline filtering and mapping.
+fun sumList(xs: Slice[Int]) -> Int =
+  total := 0
+  for x := range xs
+    total = total + x
+  return total
+fun firstOver(xs: Slice[Int], limit: Int) -> Int =
+  for x := range xs
+    if x > limit
+      return x
+  return -1
+# ==== control flow tests ====
 test "tail match without return runs correctly"
   assert bindExample(5) == 5
@@ -91,3 +117,109 @@ test "tail enum match without return runs correctly"
 test "assert passes through on true"
   assert checkPositiveAndReturn(5) == 5
+# ==== loops tests ====
+test "plain_iterable_for: List and Array"
+  xs := Slice(1, 2, 3, 4)
+  assert sumList(xs) == 10
+  arr := Array.filled(3, 7)
+  total := 0
+  for a := range arr
+    total = total + a
+  assert total == 21
+test "index_value_binders: i, x"
+  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 := 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 := 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 := Slice(1, 2, 3, 4, 5)
+  total := 0
+  for x := range xs
+    if x == 2
+      continue
+    if x == 5
+      break
+    total = total + x
+  assert total == 8
+  assert firstOver(xs, 3) == 4
+  assert firstOver(xs, 9) == -1
+test "nested iterable loops"
+  xs := Slice(1, 2)
+  ys := Slice(10, 20)
+  total := 0
+  for x := range xs
+    for y := range ys
+      total = total + x * y
+  assert total == 90
+test "range_int: 0 to n-1, empty for 0, continue still advances"
+  total := 0
+  for i := range 5
+    total = total + i
+  assert total == 10
+  n := 0
+  for _ := range 0
+    n = n + 1
+  assert n == 0
+  odd := 0
+  for i := range 6
+    if i % 2 == 0
+      continue
+    odd = odd + i
+  assert odd == 9
+test "range_until_to_downTo: bounds incl. empty ranges"
+  a := 0
+  for i := range 2.until(6)
+    a = a + i
+  assert a == 14
+  b := 0
+  for i := range 1.to(4)
+    b = b + i
+  assert b == 10
+  c := 0
+  for i := range 4.downTo(1)
+    c = c * 10 + i
+  assert c == 4321
+  n := 0
+  for _ := range 5.until(5)
+    n = n + 1
+  for _ := range 1.downTo(2)
+    n = n + 1
+  for _ := range 3.to(2)
+    n = n + 1
+  assert n == 0
+test "range_stepBy: stepBy on until and to"
+  total := 0
+  for i := range 0.until(10).stepBy(3)
+    total = total + i
+  assert total == 18
+  for i := range 1.to(10).stepBy(4)
+    total = total + i
+  assert total == 18 + 15
+test "range_seq_terminal: a terminal over an Int range"
+  evens := for i := range 0.until(10).filter()
+    i % 2 == 0
+  assert evens.length() == 5

plum-examples/digit_names.plum DELETED Viewed

@@ -1,59 +0,0 @@
-module digit_names
-import std/Int
-# Type and variant names may contain digits (`V2`, `A1`, `E1`). They are
-# resolved by position: where a type or variant name is expected it is one;
-# `Type.Name` consts such as `V2.K1` and `Int.Max` keep working.
-enum V2 =
-  | A1
-  | B2
-  K1 = 40
-record A1(n: Int)
-error S1 = E1 | E2
-fun fail(n: Int) -> S1!Int =
-  if n == 1
-    return error.E1
-  if n == 2
-    return error.E2
-  n
-fun asInt(w: V2) -> Int =
-  match w
-    A1(n) => n
-    B2 => 0
-fun payload(w: V2) -> Int =
-  if A1(n) := w
-    return n
-  0
-fun isB2(w: V2) -> Int =
-  if B2 := w
-    return 1
-  0
-test "digit_variant_match"
-  assert asInt(A1(n: 5)) == 5
-  x := B2
-  assert asInt(x) == 0
-test "digit_variant_pattern_if"
-  assert payload(A1(n: 7)) == 7
-  assert payload(B2) == 0
-  w := B2
-  assert isB2(w) == 1
-  assert isB2(A1(n: 1)) == 0
-test "digit_error_names"
-  a := fail(3) catch 0
-  assert a == 3
-  b := fail(1) catch 9
-  assert b == 9
-test "digit_enum_const_still_works"
-  assert V2.K1 == 40
-  assert Int.Max > 0

plum-examples/{error_propagation.plum → errors.plum} RENAMED Viewed

@@ -1,9 +1,12 @@
+# Errors and optionals: error propagation and T?.
 import std/Int
 import std/Float
 import std/Str
 import std/Slice
 import std/Map
+# ==== error propagation ====
 # `!T` is "a `T` or an error". An error is a value written `error.Name` (for
 # example `return error.NegativeNum`): it needs no declaration and carries no
 # data. A function's error set is inferred from its body (every error value it
@@ -158,6 +161,103 @@ record Ages[T](items: Slice[T]) =
 fun parseAges(xs: Slice[Str]) -> !Ages[Age] = Ages.parseAll(xs)
+# ==== optionals ====
+# 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`,
+# `while x := opt`, `opt!` (crashes on null) and `opt == null`; `catch` and `try`
+# are for errors only. `!T?` is an error union whose success value is an optional.
+#
+# `obj?.field` / `obj?.method(args)` is safe navigation: it reaches into an
+# optional without unwrapping it and passes null through. A field that is itself
+# a `T?` flattens, so `u?.target?.name` is one `Str?`. It is sugar for
+# `obj.andThen(|v| v.field)`.
+record Box(label: Str)
+record Holder(mut item: Box?, mut count: Int?)
+fun maybeBox(c: Bool) -> Box? =
+  if c
+    return Box(label: "in")
+  return null
+fun maybeInt(c: Bool) -> Int? =
+  if c
+    return 7
+  null
+fun orFive(n: Int? = null) -> Int =
+  n ?: 5
+fun failOnNull(c: Bool) -> error{Absent}!Int =
+  n := maybeInt(c) ?: return error.Absent
+  n + 1
+fun nullOnNull(c: Bool) -> Int? =
+  n := maybeInt(c) ?: return null
+  n * 2
+fun chainDefault(a: Int?, b: Int?) -> Int =
+  a ?: b ?: 99
+fun fallible(n: Int) -> error{Bad}!Int? =
+  if n < 0
+    return error.Bad
+  if n == 0
+    return null
+  n
+fun viaTry(n: Int) -> error{Bad}!Int =
+  v := try fallible(n)
+  v ?: -1
+fun nextItem(items: Slice[Int], i: Int) -> Int? =
+  if i < items.length()
+    return items.get(i)!
+  null
+fun sparse() -> Slice[Int?] =
+  Slice(1, null, 3)
+fun sumBig() -> Int =
+  Int.Max + Int.Min
+record Person(name: Str, age: Int) =
+  fun birthday(self) -> Int =
+    self.age + 1
+record Target(name: Str)
+record User(name: Str, target: Target?)
+fun personName(p: Person?) -> Str? =
+  p?.name
+fun personBirthday(p: Person?) -> Int? =
+  p?.birthday()
+fun somePerson() -> Person? =
+  Person(name: "Ann", age: 3)
+fun noPerson() -> Person? =
+  return null
+fun noTarget() -> Target? =
+  return null
+fun maybeCount(n: Int? = null) -> Int? =
+  n
+fun noUser() -> User? =
+  return null
+fun targetName(u: User?) -> Str? =
+  u?.target?.name
+# ==== error propagation tests ====
 test "try operator unwraps the value and propagates it through two calls"
   assert sumTwo("2", "3")! == 5
@@ -253,3 +353,141 @@ test "a Map can hold error unions as values"
   assert lookup(m) == 7
   m.set(1, negOrSeven(-2))
   assert lookup(m) == 0
+# ==== optionals tests ====
+test "null_return_absent"
+  assert maybeBox(false) == null
+  assert maybeBox(true) != null
+  assert maybeInt(false) == null
+  assert null != maybeInt(true)
+test "null_field_and_arg"
+  h := Holder(item: null, count: null)
+  assert h.item == null
+  assert h.count == null
+  h2 := Holder(item: Box(label: "x"), count: 3)
+  assert h2.count! == 3
+  assert orFive(null) == 5
+  assert orFive(8) == 8
+  xs := sparse()
+  assert xs.length() == 3
+test "elvis_default"
+  assert {maybeInt(false) ?: 4} == 4
+  assert {maybeInt(true) ?: 4} == 7
+  assert {maybeBox(false)?.label ?: "none"} == "none"
+  assert {maybeBox(true)?.label ?: "none"} == "in"
+test "elvis_return_error"
+  assert {failOnNull(true) catch 0} == 8
+  assert {failOnNull(false) catch 0} == 0
+test "elvis_return_null"
+  assert nullOnNull(true)! == 14
+  assert nullOnNull(false) == null
+test "elvis_chain_right_assoc"
+  assert chainDefault(null, null) == 99
+  assert chainDefault(null, 2) == 2
+  assert chainDefault(1, 2) == 1
+test "if_bind_optional"
+  r := 0
+  if x := maybeInt(true)
+    r = x
+  else
+    r = -1
+  assert r == 7
+  if y := maybeInt(false)
+    r = y
+  else
+    r = -1
+  assert r == -1
+  assert {if v := maybeInt(true) then v + 1 else 0} == 8
+  assert {if w := maybeInt(false) then w + 1 else 0} == 0
+  if b := maybeBox(true)
+    assert b.label == "in"
+test "while_bind_optional"
+  items := Slice(3, 2, 1)
+  total := 0
+  i := 0
+  while v := nextItem(items, i)
+    total = total + v
+    i = i + 1
+  assert total == 6
+test "safe_nav_optional_flattens"
+  assert maybeBox(true)?.label! == "in"
+  assert maybeBox(false)?.label == null
+test "null_eq_ref and null_eq_int"
+  b := maybeBox(false)
+  assert b == null
+  n := maybeInt(true)
+  assert n != null
+  assert !{n == null}
+test "error_union_of_optional"
+  assert {viaTry(5) catch 0} == 5
+  assert {viaTry(0) catch 0} == -1
+  assert {viaTry(-3) catch 100} == 100
+  x := fallible(0)!
+  assert x == null
+  y := fallible(4)!
+  assert y! == 4
+test "int_min_literal"
+  assert Int.Min == -0x8000_0000_0000_0000
+  assert sumBig() == -1
+test "reassigning an optional local or field to null or a value"
+  o := maybeInt(true)
+  o = null
+  assert o == null
+  o = 4
+  assert o! == 4
+  b := maybeBox(true)
+  b = null
+  assert b == null
+  h := Holder(item: Box(label: "x"), count: 2)
+  h.count = null
+  h.item = null
+  assert h.count == null
+  assert h.item == null
+  h.count = 5
+  h.item = Box(label: "y")
+  assert h.count! == 5
+  assert h.item!.label == "y"
+test "safe navigation maps a field access over a present value, passes absence through"
+  assert personName(somePerson())! == "Ann"
+  assert {personName(noPerson()) ?: "gone"} == "gone"
+test "safe navigation maps a method call over a present value"
+  assert personBirthday(somePerson())! == 4
+  assert {personBirthday(noPerson()) ?: -1} == -1
+test "safe navigation chains through a nullable field"
+  full := User(name: "u", target: Target(name: "home"))
+  assert {targetName(full) ?: "none"} == "home"
+  assert {targetName(User(name: "v", target: noTarget())) ?: "none"} == "none"
+  assert {targetName(noUser()) ?: "none"} == "none"
+test "?: handles a nullable with a diverging or computed default"
+  p := somePerson() ?: crash "missing"
+  assert p.age == 3
+  q := noPerson() ?: Person(name: "gone", age: 1)
+  assert q.name == "gone"
+test "null is the absent value in an argument, a list element and a default"
+  u := User(name: "w", target: null)
+  assert {targetName(u) ?: "none"} == "none"
+  xs := sparse()
+  second := xs.get(1)!
+  assert {second ?: 9} == 9
+  first := xs.get(0)!
+  assert first! == 1
+  assert {maybeCount() ?: 5} == 5
+  assert maybeCount(7)! == 7

plum-examples/forms.plum DELETED Viewed

@@ -1,155 +0,0 @@
-# User-defined `fun*` forms with `yield`: sources, folds and methods written in
-# plum and expanded at the call site (the built-in forms are in seq.plum).
-import std/Str
-import std/Int
-import std/Float
-import std/Slice
-import std/Testing
-import std/Seq
-# for-forms: `for binders := range form(args), clauses` + body. A form is a `fun*`
-# with a yield type (`*T`); each `yield` runs the `for` body, and the whole
-# thing is expanded at the call site, so there are no closures. See
-# plum-std/Seq.plum and plum-core/src/forms.rs.
-record Fighter(name: Str, hp: Int, dead: Bool)
-fun sampleFighters() -> Slice[Fighter] =
-  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: Slice[T]) *T -> Int =
-  total := 0
-  for x := range xs
-    v := yield x
-    total = total + v
-  total
-# a user form with two binders and a statement body: the 8 neighbours of (x, y)
-fun* neighbours(x: Int, y: Int) *(Int, Int) =
-  for dx := range 3
-    for dy := range 3
-      if dx != 1 || dy != 1
-        yield x + dx - 1, y + dy - 1
-# a user form built from another form: `yield` sits inside `each`'s body
-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: Slice[Int]) -> Int =
-  for x := range xs.each()
-    if x > 10
-      return x
-  return -1
-fun returnedForm(xs: Slice[Int]) -> Slice[Int] =
-  return for x := range xs.map()
-    x + 1
-fun tailForm(xs: Slice[Int]) -> Int =
-  for x := range sumBy(xs)
-    x * 2
-# A type with a fun* method: `self` is bound to the receiver at the use site.
-record Countdown(from: Int) =
-  fun* ticks(self) *Int =
-    i := self.from
-    while i > 0
-      cur := i
-      i = i - 1
-      yield cur
-  # `for a, b := range countdown`: two binders pick `entries`.
-  fun* entries(self) *(Int, Int) =
-    i := self.from
-    while i > 0
-      cur := i
-      i = i - 1
-      yield cur, cur * cur
-test "user_form_sumBy"
-  fighters := sampleFighters()
-  hp := for u := range sumBy(fighters)
-    u.hp
-  assert hp == 17
-  odd := for x := range sumBy(Slice(1, 2, 3, 4, 5)), if x % 2 == 1
-    x
-  assert odd == 9
-test "user_form_neighbours_grid: two binders, statement body"
-  count := 0
-  sum := 0
-  for nx, ny := range neighbours(5, 5), if nx > 5
-    count = count + 1
-    sum = sum + ny
-  assert count == 3
-  assert sum == 15
-test "break_continue_return_semantics"
-  xs := Slice(1, 2, 3, 4, 5)
-  total := 0
-  for x := range xs.each()
-    if x == 2
-      continue
-    if x == 5
-      break
-    total = total + x
-  assert total == 8
-  assert firstBig(Slice(1, 20, 30)) == 20
-  assert firstBig(xs) == -1
-  prefix := for x := range xs.filter()
-    if x == 4
-      break
-    x > 1
-  assert prefix.length() == 2
-test "composed form: a form that uses another form"
-  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 := Slice(1, 2)
-  ys := Slice(10, 20)
-  total := for a := range sumBy(xs)
-    inner := for b := range sumBy(ys)
-      a * b
-    inner
-  assert total == 90
-test "return for-form: the form's value is returned"
-  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(Slice(1, 2, 3)) == 12
-test "fun_star_method_uses_self"
-  c := Countdown(from: 4)
-  seen := 0
-  for t := range c.ticks()
-    seen = seen * 10 + t
-  assert seen == 4321
-  evens := for t := range c.ticks().map(), if t % 2 == 0
-    t * 100
-  assert evens.length() == 2
-  assert evens.at(0) == 400
-test "two_binder_uses_entries_method: a custom type's entries()"
-  c := Countdown(from: 3)
-  total := 0
-  for n, sq := range c
-    total = total + n * 1000 + sq
-  assert total == 3 * 1000 + 9 + 2 * 1000 + 4 + 1000 + 1
-  for _, sq := range c
-    total = total + sq
-  assert total == 6014 + 14

plum-examples/functions.plum DELETED Viewed

@@ -1,77 +0,0 @@
-# Functions: top-level function declarations, typed arguments, default and
-# variadic parameters, return expressions, and recursion.
-import std/Str
-import std/Int
-import std/Float
-fun addInts(a: Int, b: Int) -> Int =
-  a + b
-fun greet() =
-  todo
-fun withDefault(a: Int, step: Int = 1) -> Int =
-  a + step
-fun sumAll(nums: ...Int) -> Int =
-  total := 0
-  for v := range nums
-    total = total + v
-  total
-fun wrap(value: T) -> Bool =
-  true
-fun pair(first: T, second: U) -> Bool =
-  true
-fun useWrap() -> Bool =
-  wrap(5)
-fun usePair() -> Bool =
-  pair(1, "x")
-# ---- recursion, defaults and variadics ----
-fun factorial(x: Int) -> Int =
-  if x < 2
-    return 1
-  return x * factorial(x - 1)
-# Regression test: `double(...)` (an all-lowercase, no-uppercase, no-underscore
-# callee) used to fail to parse at all — `var_identifier` and `fn_identifier`
-# both matched its text and the grammar's lexer would nondeterministically
-# commit to `var_identifier`, breaking every such call site.
-fun double(n: Int) -> Int =
-  n * 2
-fun combineVariadic(prefix: Int, rest: ...Int) -> Int =
-  prefix
-fun weighted(nums: ...Int) -> Int =
-  total := 0
-  for i, v := range nums
-    total = total + i * v
-  total
-test "factorial runs correctly"
-  assert factorial(5) == 120
-test "lowercase single word function call runs correctly"
-  assert double(21) == 42
-test "variadic call with varying trailing arg counts runs correctly"
-  a := combineVariadic(10)
-  b := combineVariadic(20, 1)
-  c := combineVariadic(30, 1, 2, 3)
-  assert a + b + c == 60
-test "sum all variadic int runs correctly"
-  assert sumAll(1, 2, 3, 4) == 10
-test "sum all variadic int with zero args runs correctly"
-  assert sumAll() == 0
-test "for over a variadic binds index and element"
-  assert weighted() == 0
-  assert weighted(5, 10, 20) == 50

plum-examples/{assets → games/assets}/gameover.wav RENAMED Viewed

File without changes

plum-examples/{assets → games/assets}/hit.wav RENAMED Viewed

File without changes

plum-examples/{assets → games/assets}/music.wav RENAMED Viewed

File without changes

plum-examples/{assets → games/assets}/pickup.wav RENAMED Viewed

File without changes

plum-examples/{assets → games/assets}/sprites.png RENAMED Viewed

File without changes

plum-examples/games/functional/game_state_view.plum CHANGED Viewed

@@ -1,21 +1,23 @@
-# Orb Run as state and view (`plum game plum-examples/games/functional/game_state_view.plum`): the same
+# Orb Run as components (`plum game plum-examples/games/functional/game_state_view.plum`): the same
 # game as game_pure_scene.plum (same arena, rules, sprites, sounds, keys and scoring),
-# written the way a Rust state/view program is. Steer the ship with the arrow keys or
+# written in the component style of Elm and React but purely functional. Steer the ship
-# WASD, collect the drifting orbs and avoid the mines. Three lives; Enter, R or the
+# with the arrow keys or WASD, collect the drifting orbs and avoid the mines. Three
-# "Again" button restarts after the game is over.
+# lives; Enter, R or the "Again" button restarts after the game is over.
 #
+# Each kind (`Ship`, `Orb`, `Mine`, `Star`) keeps its data, its behaviour and its
+# drawing together: `update(self, ..)` returns the next value of the kind (a spread,
+# nothing is changed in place) and `render(self, ..)` returns its `SceneNode` picture.
-# The game is three plain pieces. `State` is plain data: the ship, the orbs and the
+# `State` is the same for the whole game: the components, the score, a `Random` and the
-# 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
+# screen size. `Msg` is what can happen to it (a tick of time, a resize, a restart, a
-# with inline variants. `step(state, msg)` is pure and returns the next `State`;
+# Ui event); `State.update(msg)` is a short sequence of named steps and
-# `view(state)` is pure too and builds a fresh `SceneNode` picture every frame, which
+# `State.render()` builds a fresh picture every frame, which `Picture.draw` interprets
-# `Picture.draw` interprets. Both are structural recursion over `Link` and `List[SceneNode]`:
-# no loop runs in `step` or `view`. There is no
+# (the compiler fuses the two, so the tree is never built). There is no retained
-# retained scene: the restart button is a `Ui.button` in the picture; the host turns
+# scene: the restart button is a `Ui.button` in the picture; the host turns the mouse
-# the mouse into a `UiInput`, finds what is under it with `Picture.hitId` on the
+# into a `UiInput`, finds what is under it with `Picture.hitId` on the picture the
-# picture the player is looking at, runs `Ui.step`, and feeds each `UiEvent` to `step`.
+# player is looking at, runs `Ui.step`, and feeds each `UiEvent` to `State.update`.
-# The game-over title and the ship's hurt flash are `Anim`s of time since they began. The `World` record is the host shell: it holds the
+# The game-over title and the ship's hurt flash are `Anim`s of time since they began.
+# The `World` record is the host shell: it holds the current `State`, reads the keyboard
-# current `State`, reads the keyboard and mouse into messages, and plays sounds.
+# and mouse into messages, and plays sounds.
 module game_state_view
 import std/Str
 import std/Int
@@ -23,12 +25,14 @@ import std/Float
 import std/Slice
 import std/List
 import std/Math
+import std/Random
 import std/game/Vec2
 import std/game/Color
 import std/game/Game
 import std/game/functional/Picture
 import std/game/functional/Anim
 import std/game/functional/Ui
+import std/Io
 primitive Rules =
   ArenaW = 800.0
@@ -46,16 +50,6 @@ primitive Rules =
   Size = 48.0
   Half = 24.0
-# Where each layer sits among the root's children in the picture `view` builds.
-primitive Slot =
-  Backdrop = 0
-  Stars = 1
-  Mines = 2
-  Orbs = 3
-  Ship = 4
-  Hud = 5
-  Overlay = 6
 # Entity ids: orb `i` is `Id.Orb + i`, mine `i` is `Id.Mine + i`.
 primitive Id =
   Orb = 100
@@ -65,71 +59,8 @@ primitive Id =
 # A position and velocity: what a spawn returns and what drifters are bounced with.
 struct Motion(x: Float, y: Float, vx: Float, vy: Float)
-# A random spot plus the seed to continue from.
+# A random spot and the generator to continue from.
-struct Spawn(x: Float, y: Float, vx: Float, vy: Float, seed: Int)
-struct ShipState(x: Float, y: Float, vx: Float, vy: Float, rotation: Float, hurt: Float)
-struct Orb(id: Int, x: Float, y: Float, vx: Float, vy: Float, phase: Float, clock: Float)
-struct Mine(id: Int, x: Float, y: Float, vx: Float, vy: Float, rotation: Float, spin: Float, clock: Float)
-# Everything that changes during a run. `sheet` and `target` are resource handles
-# the view needs: the sprite sheet and the render target of the game-over filter.
-record State(
-  ship: ShipState,
-  orbs: List[Orb],
-  mines: List[Mine],
-  seed: Int,
-  score: Int,
-  best: Int,
-  lives: Int,
-  over: Bool,
-  clock: Float,
-  overClock: Float,
-  hurtAt: Float,
-  overAt: Float,
-  ui: UiState,
-  sw: Float,
-  sh: Float,
-  sheet: Int,
-  target: Int)
-# What can happen to the state.
-enum Msg =
-  | Tick(dt: Float, ax: Float, ay: Float)
+record Spawned(at: Motion, rng: Random)
-  | Resize(w: Float, h: Float)
-  | Restart(seed: Int)
-  | UiEv(event: UiEvent)
-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: List[T]) -> Int = match xs
-  Nil => 0
-  Cons(_, t) => 1 + lenLink(t)
-# `xs` with `x` added at the end.
-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: 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: 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: List[T], f: fn(T) -> SceneNode, rest: List[SceneNode]) -> List[SceneNode] = match xs
-  Nil => rest
-  Cons(h, t) => Cons(head: f(h), tail: toNodes(t, f, rest))
 # --- small pure helpers ---
@@ -137,269 +68,51 @@ fun toNodes(xs: List[T], f: fn(T) -> SceneNode, rest: List[SceneNode]) -> List[S
 fun frameOf(clock: Float, count: Int, fps: Float) -> Int =
   Int(clock * fps) % count
-fun nextSeed(seed: Int) -> Int =
+fun nothing() -> SceneNode =
-  {seed * 1103515245 + 12345} % 2147483648
+  Group(transform: Identity, children: Nil)
+fun cell(sheet: Int, x: Float, y: Float, size: Float, col: Int, row: Int) -> SceneNode =
+  Sprite(
+    tex: sheet, x: x, y: y, w: size, h: size, srcX: Float(col) * Rules.Cell, srcY: Float(row) * Rules.Cell,
+    srcW: Rules.Cell, srcH: Rules.Cell, tint: Color.White)
-# A float in 0..1 from a seed.
-fun unit(seed: Int) -> Float =
+fun overlaps(ax: Float, ay: Float, ra: Float, bx: Float, by: Float, rb: Float) -> Bool =
-  Float({seed / 65536} % 32768) / 32768.0
+  Math.hypot(ax - bx, ay - by) < ra + rb
 # A random spot at least `gap` away from (ax, ay), drifting at up to `speed`.
-fun spawn(seed: Int, ax: Float, ay: Float, gap: Float, speed: Float) -> Spawn =
+fun spawn(rng: Random, ax: Float, ay: Float, gap: Float, speed: Float) -> Spawned =
   margin := 30.0
-  sd := seed
+  r := rng
   x := 0.0
   y := 0.0
   tries := 0
   while tries < 20
-    sd = nextSeed(sd)
+    dx := r.nextFloat()
+    dy := dx.rng.nextFloat()
+    r = dy.rng
-    x = margin + unit(sd) * {Rules.ArenaW - 2.0 * margin}
+    x = margin + dx.value * {Rules.ArenaW - 2.0 * margin}
-    sd = nextSeed(sd)
-    y = margin + unit(sd) * {Rules.ArenaH - 2.0 * margin}
+    y = margin + dy.value * {Rules.ArenaH - 2.0 * margin}
     if Math.hypot(x - ax, y - ay) >= gap
       break
     tries = tries + 1
-  sd = nextSeed(sd)
+  dh := r.nextFloat()
+  dp := dh.rng.nextFloat()
-  heading := unit(sd) * Float.Tau
+  heading := dh.value * Float.Tau
-  sd = nextSeed(sd)
-  pace := speed * {0.4 + 0.6 * unit(sd)}
+  pace := speed * {0.4 + 0.6 * dp.value}
-  Spawn(x: x, y: y, vx: Math.cos(heading) * pace, vy: Math.sin(heading) * pace, seed: sd)
+  Spawned(at: Motion(x: x, y: y, vx: Math.cos(heading) * pace, vy: Math.sin(heading) * pace), rng: dp.rng)
 # `b` moved for `dt` seconds and bounced off the arena walls; `b` itself is unchanged.
 fun driftOf(b: Motion, r: Float, dt: Float) -> Motion =
-  x := b.x + b.vx * dt
+  x0 := b.x + b.vx * dt
-  y := b.y + b.vy * dt
+  y0 := b.y + b.vy * dt
-  vx := b.vx
-  vy := b.vy
-  if x < r || x > Rules.ArenaW - r
-    vx = 0.0 - b.vx
-    x = x.max(r).min(Rules.ArenaW - r)
+  x := x0.max(r).min(Rules.ArenaW - r)
-  if y < r || y > Rules.ArenaH - r
-    vy = 0.0 - b.vy
-    y = y.max(r).min(Rules.ArenaH - r)
+  y := y0.max(r).min(Rules.ArenaH - r)
-  Motion(x: x, y: y, vx: vx, vy: vy)
+  Motion(x: x, y: y, vx: if x != x0 then 0.0 - b.vx else b.vx, vy: if y != y0 then 0.0 - b.vy else b.vy)
 # How many mines are out: more as the score grows.
 fun mineCount(score: Int) -> Int =
   {3 + score / 50}.min(8)
-# Accelerates by the input axes, applies drag and keeps the ship in the arena.
-fun shipStep(s: ShipState, ax: Float, ay: Float, dt: Float) -> ShipState =
-  keep := {1.0 - Rules.Drag * dt}.max(0.0)
-  vx := {s.vx + ax * Rules.Thrust * dt} * keep
-  vy := {s.vy + ay * Rules.Thrust * dt} * keep
-  x := s.x + vx * dt
-  y := s.y + vy * dt
-  r := Rules.ShipRadius
-  if x < r
-    x = r
-    vx = 0.0
-  if x > Rules.ArenaW - r
-    x = Rules.ArenaW - r
-    vx = 0.0
-  if y < r
-    y = r
-    vy = 0.0
-  if y > Rules.ArenaH - r
-    y = Rules.ArenaH - r
-    vy = 0.0
-  rot := s.rotation
-  if vx * vx + vy * vy > 400.0
-    rot = Math.atan2(vx, 0.0 - vy)
-  ShipState(x: x, y: y, vx: vx, vy: vy, rotation: rot, hurt: {s.hurt - dt}.max(0.0))
-fun newShip() -> ShipState =
-  ShipState(x: Rules.ArenaW / 2.0, y: Rules.ArenaH / 2.0, vx: 0.0, vy: 0.0, rotation: 0.0, hurt: 0.0)
-fun overlaps(ax: Float, ay: Float, ra: Float, bx: Float, by: Float, rb: Float) -> Bool =
-  Math.hypot(ax - bx, ay - by) < ra + rb
-fun orbAt(id: Int, phase: Float, clock: Float, at: Motion) -> Orb =
-  Orb(id: id, x: at.x, y: at.y, vx: at.vx, vy: at.vy, phase: phase, clock: clock)
-fun mineAt(id: Int, rotation: Float, spin: Float, clock: Float, at: Motion) -> Mine =
-  Mine(id: id, x: at.x, y: at.y, vx: at.vx, vy: at.vy, rotation: rotation, spin: spin, clock: clock)
-fun orbMove(o: Orb, dt: Float) -> Orb =
-  m := driftOf(Motion(x: o.x, y: o.y, vx: o.vx, vy: o.vy), Rules.OrbRadius, dt)
-  orbAt(o.id, o.phase, o.clock + dt, m)
-fun mineMove(k: Mine, dt: Float) -> Mine =
-  m := driftOf(Motion(x: k.x, y: k.y, vx: k.vx, vy: k.vy), Rules.MineRadius, dt)
-  mineAt(k.id, k.rotation + k.spin * dt, k.spin, k.clock + dt, m)
-# --- the state ---
-# A built list of orbs and the seed to continue from.
-record OrbsMade(orbs: List[Orb], 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 =
-  if i >= Rules.OrbCount
-    return OrbsMade(orbs: Nil, seed: seed)
-  sp := spawn(seed, ship.x, ship.y, 120.0, 40.0)
-  rest := makeOrbs(i + 1, sp.seed, ship)
-  OrbsMade(orbs: Cons(head: orbAt(Id.Orb + i, Float(i) * 0.1, 0.0, Motion(x: sp.x, y: sp.y, vx: sp.vx, vy: sp.vy)), tail: rest.orbs), seed: rest.seed)
-# Mines `i` and up to `count`.
-fun makeMines(i: Int, count: Int, seed: Int, ship: ShipState) -> MinesMade =
-  if i >= count
-    return MinesMade(mines: Nil, seed: seed)
-  sp := spawn(seed, ship.x, ship.y, 220.0, 90.0)
-  rest := makeMines(i + 1, count, sp.seed, ship)
-  MinesMade(mines: Cons(head: mineAt(Id.Mine + i, 0.0, 2.0, 0.0, Motion(x: sp.x, y: sp.y, vx: sp.vx, vy: sp.vy)), tail: rest.mines), seed: rest.seed)
-fun newState(seed: Int, best: Int, sheet: Int, target: Int, sw: Float, sh: Float) -> State =
-  ship := newShip()
-  made := makeOrbs(0, seed, ship)
-  mm := makeMines(0, mineCount(0), made.seed, ship)
-  State(
-    ship: ship, orbs: made.orbs, mines: mm.mines, seed: mm.seed, score: 0, best: best, lives: Rules.StartLives,
-    over: false, clock: 0.0, overClock: 0.0, hurtAt: -1.0, overAt: -1.0, ui: Ui.init(), sw: sw, sh: sh, sheet: sheet, target: target)
-fun orbStill(o: Orb) -> Orb =
-  orbAt(o.id, o.phase, o.clock, Motion(x: o.x, y: o.y, vx: 0.0, vy: 0.0))
-fun mineStill(k: Mine) -> Mine =
-  mineAt(k.id, k.rotation, 0.0, k.clock, Motion(x: k.x, y: k.y, vx: 0.0, vy: 0.0))
-# Stops every orb and mine: after game over they only animate.
-fun freeze(s: State) -> State =
-  n := State(..s)
-  n.orbs = mapLink(s.orbs, |o| orbStill(o))
-  n.mines = mapLink(s.mines, |k| mineStill(k))
-  n
-# The orbs after the ship collected the ones it touches, with the score and seed.
-record Collected(orbs: List[Orb], seed: Int, score: Int)
-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)
-      sp := spawn(seed, ship.x, ship.y, 120.0, 40.0)
-      later := collectOrbs(rest, ship, sp.seed, score + Rules.OrbPoints)
-      moved := orbAt(o.id, o.phase, o.clock, Motion(x: sp.x, y: sp.y, vx: sp.vx, vy: sp.vy))
-      Collected(orbs: Cons(head: moved, tail: later.orbs), seed: later.seed, score: later.score)
-    else
-      kept := collectOrbs(rest, ship, seed, score)
-      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: 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: 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)
-# One frame of time. Once the game is over the actors only animate.
-fun tick(s: State, dt: Float, ax: Float, ay: Float) -> State =
-  n := State(..s)
-  n.clock = s.clock + dt
-  n.orbs = mapLink(s.orbs, |o| orbMove(o, dt))
-  n.mines = mapLink(s.mines, |k| mineMove(k, dt))
-  if s.over
-    n.overClock = s.overClock + dt
-    return n
-  ship := shipStep(s.ship, ax, ay, dt)
-  n.ship = ship
-  got := collectOrbs(n.orbs, ship, n.seed, n.score)
-  n.orbs = got.orbs
-  n.seed = got.seed
-  n.score = got.score
-  grown := growMines(n.mines, lenLink(n.mines), mineCount(n.score), n.seed, ship)
-  n.mines = grown.mines
-  n.seed = grown.seed
-  if n.ship.hurt <= 0.0 && touchesMine(n.mines, ship)
-    n.lives = n.lives - 1
-    n.ship = ShipState(x: ship.x, y: ship.y, vx: ship.vx, vy: ship.vy, rotation: ship.rotation, hurt: Rules.HurtTime)
-    n.hurtAt = n.clock
-    if n.lives <= 0
-      n.over = true
-      n.overAt = n.clock
-      n.best = n.best.max(n.score)
-  if n.over
-    return freeze(n)
-  n
-# The next state: pure, nothing that is passed in is changed.
-fun step(s: State, msg: Msg) -> State = match msg
-  Tick(dt, ax, ay) => tick(s, dt, ax, ay)
-  Resize(w, h) => resized(s, w, h)
-  Restart(seed) => restarted(s, seed)
-  UiEv(event) => uiEvent(s, event)
-fun restarted(s: State, seed: Int) -> State =
-  n := newState(seed, s.best.max(s.score), s.sheet, s.target, s.sw, s.sh)
-  n.ui = s.ui
-  n
-# A click on the restart button restarts a finished game; other events change nothing.
-fun uiEvent(s: State, e: UiEvent) -> State =
-  if s.over && e.id == Id.Restart && e.kind == Click
-    return restarted(s, nextSeed(s.seed))
-  s
-fun resized(s: State, w: Float, h: Float) -> State =
-  n := State(..s)
-  n.sw = w
-  n.sh = h
-  n
-# The zoom that fits the arena into the screen, and where the arena's corner lands.
-fun zoomOf(s: State) -> Float =
-  {s.sw / Rules.ArenaW}.min(s.sh / Rules.ArenaH)
-fun offsetX(s: State) -> Float =
-  {s.sw - zoomOf(s) * Rules.ArenaW} / 2.0
-fun offsetY(s: State) -> Float =
-  {s.sh - zoomOf(s) * Rules.ArenaH} / 2.0
-# --- the view ---
-fun cell(sheet: Int, x: Float, y: Float, size: Float, col: Int, row: Int) -> SceneNode =
-  Sprite(
-    tex: sheet, x: x, y: y, w: size, h: size, srcX: Float(col) * Rules.Cell, srcY: Float(row) * Rules.Cell,
-    srcW: Rules.Cell, srcH: Rules.Cell, tint: Color.White)
-fun starView(i: Int, clock: Float) -> SceneNode =
-  r := 1.0 + Float(i % 3) * 0.5
-  twinkle := 0.25 + 0.2 * Math.sin(clock * 2.0 + Float(i))
-  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) -> List[SceneNode] =
-  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))
-fun mineView(sheet: Int, k: Mine) -> SceneNode =
-  Group(
-    transform: Compose(first: Translate(dx: k.x, dy: k.y), then: Rotate(radians: k.rotation)),
-    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: 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: 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: Cons(
-      head: Filter(effect: BlendFx(mode: Blend.Add), child: glow, target: 0 - 1),
-      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 hurt flash: the ship shrinks and recovers every 0.1 s (the scale returns to 1 each lap).
 fun hitFlash() -> Anim =
   Forever(anim: Seq(steps: List(ScaleTo(sx: 0.4, sy: 0.4, secs: 0.05), ScaleTo(sx: 2.5, sy: 2.5, secs: 0.05))))
@@ -416,85 +129,297 @@ fun titleAnim() -> Anim =
 fun titlePose(t: Float) -> AnimPose =
   Anim.at(titleAnim(), t)
-fun titleView(s: State) -> SceneNode =
-  p := titlePose(s.clock - s.overAt)
-  Group(
-    transform: Compose(first: Translate(dx: 400.0 + p.dx, dy: 268.0 + p.dy), then: Scale(sx: p.scaleX, sy: p.scaleY)),
-    children: Cons(head: Text(text: "Game over", x: -100.0, y: -24.0, size: 48.0, color: Color.Red), 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 && flashPose(s.clock - s.hurtAt).scaleX < 0.7
-  if s.over || blink
-    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: 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: 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) -> List[SceneNode] =
-  if i >= lives
-    Nil
-  else
-    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: Cons(
-      head: Text(text: "Score {s.score}", x: 16.0, y: 12.0, size: 28.0, color: Color.White),
-      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: Nil)
-  button := Ui.button(Id.Restart, "Again", 340.0, 342.0, 120.0, 44.0, s.ui)
-  panel := Group(
-    transform: Identity,
-    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: Cons(
-        head: titleView(s),
-        tail: Cons(
-          head: Text(text: "Press Enter to play again", x: 270.0, y: 300.0, size: 24.0, color: Color.White),
-          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 := 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: Cons(
-      head: starsView(s.clock),
-      tail: Cons(
-        head: Group(transform: Identity, children: toNodes(s.mines, |k| mineView(s.sheet, k), Nil)),
-        tail: Cons(
-          head: Group(transform: Identity, children: toNodes(s.orbs, |o| orbView(s.sheet, o), Nil)),
-          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.
-fun onRestart(s: State, x: Float, y: Float) -> Bool =
-  if h := Picture.hitId(view(s), x, y)
-    return h == Id.Restart
-  false
-# One pointer input: finds what is under it in the current view, runs the Ui, and
-# feeds each raised event to `step`.
-fun feed(s: State, input: UiInput) -> State =
-  r := Ui.step(s.ui, input, Picture.hitId(view(s), input.x, input.y))
-  n := State(..s)
-  n.ui = r.ui
-  feedEvents(n, r.events)
-fun feedEvents(s: State, evs: List[UiEvent]) -> State = match evs
-  Nil => s
-  Cons(e, rest) => feedEvents(step(s, UiEv(event: e)), rest)
+# --- the components ---
+# The player.
+record Ship(x: Float, y: Float, vx: Float, vy: Float, rotation: Float, hurt: Float) =
+  fun start() -> Ship =
+    Ship(x: Rules.ArenaW / 2.0, y: Rules.ArenaH / 2.0, vx: 0.0, vy: 0.0, rotation: 0.0, hurt: 0.0)
+  # Accelerates by the input axes, applies drag and keeps the ship in the arena.
+  fun update(self, ax: Float, ay: Float, dt: Float) -> Ship =
+    keep := {1.0 - Rules.Drag * dt}.max(0.0)
+    r := Rules.ShipRadius
+    vx0 := {self.vx + ax * Rules.Thrust * dt} * keep
+    vy0 := {self.vy + ay * Rules.Thrust * dt} * keep
+    x0 := self.x + vx0 * dt
+    y0 := self.y + vy0 * dt
+    x := x0.max(r).min(Rules.ArenaW - r)
+    y := y0.max(r).min(Rules.ArenaH - r)
+    vx := if x != x0 then 0.0 else vx0
+    vy := if y != y0 then 0.0 else vy0
+    Ship(
+      x: x, y: y, vx: vx, vy: vy,
+      rotation: if vx * vx + vy * vy > 400.0 then Math.atan2(vx, 0.0 - vy) else self.rotation,
+      hurt: {self.hurt - dt}.max(0.0))
+  fun touches(self, at: Motion, radius: Float) -> Bool =
+    overlaps(self.x, self.y, Rules.ShipRadius, at.x, at.y, radius)
+  # The ship blinks while hurt (`hurtAge` seconds since the hit).
+  fun render(self, sheet: Int, clock: Float, hurtAge: Float) -> SceneNode =
+    blink := self.hurt > 0.0 && flashPose(hurtAge).scaleX < 0.7
+    if blink
+      nothing()
+    else
+      Group(
+        transform: Compose(first: Translate(dx: self.x, dy: self.y), then: Rotate(radians: self.rotation)),
+        children: List(
+          CircleShape(cx: 0.0, cy: 0.0, r: 17.0, color: Color(r: 0.4, g: 0.8, b: 1.0, a: 0.12)),
+          cell(sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(clock, 4, 14.0), 0)))
+# A glowing orb drifting about. `phase` offsets its animation from the other orbs.
+record Orb(id: Int, at: Motion, phase: Float, clock: Float) =
+  fun update(self, dt: Float) -> Orb =
+    Orb(..self, at: driftOf(self.at, Rules.OrbRadius, dt), clock: self.clock + dt)
+  fun moved(self, to: Motion) -> Orb =
+    Orb(..self, at: to)
+  fun still(self) -> Orb =
+    p := self.at
+    Orb(..self, at: Motion(..p, vx: 0.0, vy: 0.0))
+  # The glow is drawn additively, then the sprite on top.
+  fun render(self, sheet: Int) -> SceneNode =
+    glow := Group(
+      transform: Identity,
+      children: List(
+        CircleShape(cx: 0.0, cy: 0.0, r: 26.0, color: Color(r: 0.35, g: 0.22, b: 0.0, a: 0.5)),
+        CircleShape(cx: 0.0, cy: 0.0, r: 17.0, color: Color(r: 0.6, g: 0.4, b: 0.05, a: 0.5))))
+    Group(
+      transform: Translate(dx: self.at.x, dy: self.at.y),
+      children: List(
+        Filter(effect: BlendFx(mode: Blend.Add), child: glow, target: 0 - 1),
+        cell(sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(self.clock + self.phase, 4, 8.0), 1)))
+# A spinning mine drifting about.
+record Mine(id: Int, at: Motion, rotation: Float, spin: Float, clock: Float) =
+  fun update(self, dt: Float) -> Mine =
+    Mine(..self, at: driftOf(self.at, Rules.MineRadius, dt), rotation: self.rotation + self.spin * dt, clock: self.clock + dt)
+  fun moved(self, to: Motion) -> Mine =
+    Mine(..self, at: to)
+  fun still(self) -> Mine =
+    p := self.at
+    Mine(..self, at: Motion(..p, vx: 0.0, vy: 0.0), spin: 0.0)
+  fun render(self, sheet: Int) -> SceneNode =
+    Group(
+      transform: Compose(first: Translate(dx: self.at.x, dy: self.at.y), then: Rotate(radians: self.rotation)),
+      children: List(cell(sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(self.clock, 4, 4.0), 2)))
+# A twinkling background star; it never moves.
+record Star(i: Int) =
+  # Stars `i` and up to 40.
+  fun field(i: Int) -> List[Star] =
+    if i >= 40 then Nil else Cons(head: Star(i: i), tail: Star.field(i + 1))
+  fun render(self, clock: Float) -> SceneNode =
+    r := 1.0 + Float(self.i % 3) * 0.5
+    twinkle := 0.25 + 0.2 * Math.sin(clock * 2.0 + Float(self.i))
+    CircleShape(cx: Float({self.i * 7919} % 800), cy: Float({self.i * 104729} % 600), r: r, color: Color(r: 0.7, g: 0.8, b: 1.0, a: twinkle))
+# What can happen to the state.
+enum Msg =
+  | Tick(dt: Float, ax: Float, ay: Float)
+  | Resize(w: Float, h: Float)
+  | Restart(seed: Int)
+  | UiEv(event: UiEvent)
+# Everything that changes during a run. `sheet` and `target` are resource handles
+# the picture needs: the sprite sheet and the render target of the game-over filter.
+record State(
+  ship: Ship,
+  orbs: List[Orb],
+  mines: List[Mine],
+  stars: List[Star],
+  rng: Random,
+  score: Int,
+  best: Int,
+  lives: Int,
+  over: Bool,
+  clock: Float,
+  overClock: Float,
+  hurtAt: Float,
+  overAt: Float,
+  ui: UiState,
+  sw: Float,
+  sh: Float,
+  sheet: Int,
+  target: Int) =
+  # A fresh run: the orbs and the mines spread over the arena away from the ship.
+  fun start(seed: Int, best: Int, sheet: Int, target: Int, sw: Float, sh: Float) -> State =
+    State(
+      ship: Ship.start(), orbs: Nil, mines: Nil, stars: Star.field(0), rng: Random.seeded(seed), score: 0, best: best,
+      lives: Rules.StartLives, over: false, clock: 0.0, overClock: 0.0, hurtAt: -1.0, overAt: -1.0, ui: Ui.init(),
+      sw: sw, sh: sh, sheet: sheet, target: target).fillOrbs(0).growMines()
+  # --- update ---
+  fun update(self, msg: Msg) -> State = match msg
+    Tick(dt, ax, ay) => self.tick(dt, ax, ay)
+    Resize(w, h) => State(..self, sw: w, sh: h)
+    Restart(seed) => self.restarted(seed)
+    UiEv(event) => self.onUi(event)
+  # One frame of time. Once the game is over the actors only animate.
+  fun tick(self, dt: Float, ax: Float, ay: Float) -> State =
+    moved := self.moveAll(dt)
+    if self.over
+      State(..moved, overClock: self.overClock + dt)
+    else
+      moved.sail(ax, ay, dt).collect().growMines().hurt().settle()
+  fun moveAll(self, dt: Float) -> State =
+    State(..self, clock: self.clock + dt, orbs: self.orbs.map(|o| o.update(dt)), mines: self.mines.map(|k| k.update(dt)))
+  fun sail(self, ax: Float, ay: Float, dt: Float) -> State =
+    State(..self, ship: self.ship.update(ax, ay, dt))
+  # The ship collects every orb it touches.
+  fun collect(self) -> State =
+    self.orbs.fold(self, |s, o| s.takeOrb(o))
+  fun takeOrb(self, o: Orb) -> State =
+    if self.ship.touches(o.at, Rules.OrbRadius) then self.respawnOrb(o) else self
+  # Scores `o` and puts it at a new random spot.
+  fun respawnOrb(self, o: Orb) -> State =
+    sp := spawn(self.rng, self.ship.x, self.ship.y, 120.0, 40.0)
+    State(
+      ..self, orbs: self.orbs.map(|x| if x.id == o.id then x.moved(sp.at) else x), rng: sp.rng,
+      score: self.score + Rules.OrbPoints)
+  # Orbs `i` and up to OrbCount, each at a random spot away from the ship.
+  fun fillOrbs(self, i: Int) -> State =
+    if i >= Rules.OrbCount then self else self.addOrb(i).fillOrbs(i + 1)
+  fun addOrb(self, i: Int) -> State =
+    sp := spawn(self.rng, self.ship.x, self.ship.y, 120.0, 40.0)
+    State(
+      ..self, orbs: self.orbs.append(List(Orb(id: Id.Orb + i, at: sp.at, phase: Float(i) * 0.1, clock: 0.0))),
+      rng: sp.rng)
+  # Mines are added (at the end) until there are as many as the score asks for.
+  fun growMines(self) -> State =
+    if self.mines.length() >= mineCount(self.score) then self else self.addMine().growMines()
+  fun addMine(self) -> State =
+    sp := spawn(self.rng, self.ship.x, self.ship.y, 220.0, 90.0)
+    State(
+      ..self,
+      mines: self.mines.append(List(Mine(id: Id.Mine + self.mines.length(), at: sp.at, rotation: 0.0, spin: 2.0, clock: 0.0))),
+      rng: sp.rng)
+  fun touchesMine(self) -> Bool =
+    self.mines.fold(false, |hit, k| hit || self.ship.touches(k.at, Rules.MineRadius))
+  # A mine costs a life, makes the ship flash and, at the last life, ends the game.
+  fun hurt(self) -> State =
+    if self.ship.hurt <= 0.0 && self.touchesMine() then self.struck() else self
+  fun struck(self) -> State =
+    lives := self.lives - 1
+    done := lives <= 0
+    ship := self.ship
+    State(
+      ..self, lives: lives, ship: Ship(..ship, hurt: Rules.HurtTime), hurtAt: self.clock, over: done,
+      overAt: if done then self.clock else self.overAt, best: if done then self.best.max(self.score) else self.best)
+  # After game over the orbs and mines stop: they only animate.
+  fun settle(self) -> State =
+    if self.over then State(..self, orbs: self.orbs.map(|o| o.still()), mines: self.mines.map(|k| k.still())) else self
+  fun restarted(self, seed: Int) -> State =
+    fresh := State.start(seed, self.best.max(self.score), self.sheet, self.target, self.sw, self.sh)
+    State(..fresh, ui: self.ui)
+  # A click on the restart button restarts a finished game; other events change nothing.
+  fun onUi(self, e: UiEvent) -> State =
+    if self.over && e.id == Id.Restart && e.kind == Click then self.restarted(self.rng.nextInt().value) else self
+  # One pointer input: finds what is under it in the current picture, runs the Ui, and
+  # feeds each raised event to `update`.
+  fun feed(self, input: UiInput) -> State =
+    r := Ui.step(self.ui, input, Picture.hitId(self.render(), input.x, input.y))
+    r.events.fold(State(..self, ui: r.ui), |s, e| s.update(UiEv(event: e)))
+  # --- render ---
+  # The zoom that fits the arena into the screen, and where the arena's corner lands.
+  fun zoom(self) -> Float =
+    {self.sw / Rules.ArenaW}.min(self.sh / Rules.ArenaH)
+  fun offsetX(self) -> Float =
+    {self.sw - self.zoom() * Rules.ArenaW} / 2.0
+  fun offsetY(self) -> Float =
+    {self.sh - self.zoom() * Rules.ArenaH} / 2.0
+  # The whole picture, in drawing order, under the camera that fits the arena on screen.
+  fun render(self) -> SceneNode =
+    z := self.zoom()
+    Group(
+      transform: Compose(first: Translate(dx: self.offsetX(), dy: self.offsetY()), then: Scale(sx: z, sy: z)),
+      children: List(
+        RectShape(x: 0.0, y: 0.0, w: Rules.ArenaW, h: Rules.ArenaH, color: Color.rgb(0.07, 0.08, 0.16)),
+        Group(transform: Identity, children: self.stars.map(|st| st.render(self.clock))),
+        Group(transform: Identity, children: self.mines.map(|k| k.render(self.sheet))),
+        Group(transform: Identity, children: self.orbs.map(|o| o.render(self.sheet))),
+        self.renderShip(),
+        self.renderHud(),
+        self.renderOverlay()))
+  # The ship is gone once the game is over (an empty group keeps the slots).
+  fun renderShip(self) -> SceneNode =
+    if self.over then nothing() else self.ship.render(self.sheet, self.clock, self.clock - self.hurtAt)
+  # One life icon per remaining life, from the right edge going left.
+  fun lifeIcons(self, i: Int) -> List[SceneNode] =
+    if i >= self.lives
+      Nil
+    else
+      Cons(head: cell(self.sheet, Rules.ArenaW - 40.0 - Float(i) * 36.0, 12.0, 32.0, 0, 0), tail: self.lifeIcons(i + 1))
+  fun renderHud(self) -> SceneNode =
+    Group(
+      transform: Identity,
+      children: Cons(
+        head: Text(text: "Score {self.score}", x: 16.0, y: 12.0, size: 28.0, color: Color.White),
+        tail: Cons(head: Text(text: "Best {self.best.max(self.score)}", x: 16.0, y: 44.0, size: 20.0, color: Color.Yellow), tail: self.lifeIcons(0))))
+  fun renderTitle(self) -> SceneNode =
+    p := titlePose(self.clock - self.overAt)
+    Group(
+      transform: Compose(first: Translate(dx: 400.0 + p.dx, dy: 268.0 + p.dy), then: Scale(sx: p.scaleX, sy: p.scaleY)),
+      children: List(Text(text: "Game over", x: -100.0, y: -24.0, size: 48.0, color: Color.Red)))
+  # The game-over panel is empty while playing, so nothing in it can be hit.
+  fun renderOverlay(self) -> SceneNode =
+    if self.over then self.renderPanel() else nothing()
+  # The panel with the restart button, faded in through a render-target filter.
+  fun renderPanel(self) -> SceneNode =
+    button := Ui.button(Id.Restart, "Again", 340.0, 342.0, 120.0, 44.0, self.ui)
+    panel := Group(
+      transform: Identity,
+      children: List(
+        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)),
+        self.renderTitle(),
+        Text(text: "Press Enter to play again", x: 270.0, y: 300.0, size: 24.0, color: Color.White),
+        button))
+    Filter(effect: Alpha(alpha: {self.overClock * 2.0}.min(1.0)), child: panel, target: self.target)
+  # True when (x, y) in screen pixels is on the restart button of the picture `render` builds.
+  fun onRestart(self, x: Float, y: Float) -> Bool =
+    {Picture.hitId(self.render(), x, y) ?: -1} == Id.Restart
 fun pointerKind(down: Bool, wasDown: Bool) -> UiInputKind =
   if down && !wasDown
@@ -506,22 +431,22 @@ fun pointerKind(down: Bool, wasDown: Bool) -> UiInputKind =
 # --- the host shell ---
-record World(state: State, wasDown: Bool, pickupSound: Int, hitSound: Int, overSound: Int, musicSound: Int)
+record World(mut state: State, mut wasDown: Bool, pickupSound: Int, hitSound: Int, overSound: Int, musicSound: Int)
 fun musicVolume() -> Float =
   0.3
 # Restarts the music loop from the top.
-fun startMusic(w: World) =
+fun startMusic(io: Io, w: World) =
-  soundStop(w.musicSound)
+  io.soundStop(w.musicSound)
-  soundLoop(w.musicSound, musicVolume())
+  io.soundLoop(w.musicSound, musicVolume())
-export fun init() -> World =
+export fun init(io: Io) -> World =
-  s := newState(2024, 0, textureLoad("sprites.png"), textureCreate(1600, 1200), Rules.ArenaW, Rules.ArenaH)
+  s := State.start(io.randomSeed(), 0, io.textureLoad("sprites.png"), io.textureCreate(1600, 1200), Rules.ArenaW, Rules.ArenaH)
   w := World(
-    state: s, wasDown: false, pickupSound: soundLoad("pickup.wav"), hitSound: soundLoad("hit.wav"),
+    state: s, wasDown: false, pickupSound: io.soundLoad("pickup.wav"), hitSound: io.soundLoad("hit.wav"),
-    overSound: soundLoad("gameover.wav"), musicSound: soundLoad("music.wav"))
+    overSound: io.soundLoad("gameover.wav"), musicSound: io.soundLoad("music.wav"))
-  startMusic(w)
+  startMusic(io, w)
   w
 fun axis(negative: Bool, positive: Bool) -> Float =
@@ -532,39 +457,39 @@ fun axis(negative: Bool, positive: Bool) -> Float =
   else
     0.0
-export fun update(w: World, dt: Float) =
+export fun update(io: Io, w: World, dt: Float) =
-  s := step(w.state, Resize(w: screenWidth(), h: screenHeight()))
+  s := w.state.update(Resize(w: io.screenWidth(), h: io.screenHeight()))
-  down := isMouseDown(0)
+  down := io.isMouseDown(0)
-  m := mousePos()
+  m := io.mousePos()
-  clicked := feed(s, UiInput(kind: pointerKind(down, w.wasDown), x: m.x, y: m.y))
+  clicked := s.feed(UiInput(kind: pointerKind(down, w.wasDown), x: m.x, y: m.y))
   w.wasDown = down
   if s.over && !clicked.over
     w.state = clicked
-    startMusic(w)
+    startMusic(io, w)
     return
-  s = clicked
-  if s.over && {isKeyPressed(Key.Enter) || isKeyPressed(Key.KeyR)}
+  if clicked.over && {io.isKeyPressed(Key.Enter) || io.isKeyPressed(Key.KeyR)}
-    w.state = step(s, Restart(seed: nextSeed(s.seed)))
+    w.state = clicked.update(Restart(seed: clicked.rng.nextInt().value))
-    startMusic(w)
+    startMusic(io, w)
     return
-  left := isKeyDown(Key.Left) || isKeyDown(Key.KeyA)
+  left := io.isKeyDown(Key.Left) || io.isKeyDown(Key.KeyA)
-  right := isKeyDown(Key.Right) || isKeyDown(Key.KeyD)
+  right := io.isKeyDown(Key.Right) || io.isKeyDown(Key.KeyD)
-  up := isKeyDown(Key.Up) || isKeyDown(Key.KeyW)
+  up := io.isKeyDown(Key.Up) || io.isKeyDown(Key.KeyW)
-  downKey := isKeyDown(Key.Down) || isKeyDown(Key.KeyS)
+  downKey := io.isKeyDown(Key.Down) || io.isKeyDown(Key.KeyS)
-  t := step(s, Tick(dt: dt, ax: axis(left, right), ay: axis(up, downKey)))
+  t := clicked.update(Tick(dt: dt, ax: axis(left, right), ay: axis(up, downKey)))
-  if t.score > s.score
+  if t.score > clicked.score
-    soundPlay(w.pickupSound, 0.8)
+    io.soundPlay(w.pickupSound, 0.8)
-  if t.lives < s.lives
+  if t.lives < clicked.lives
     if t.over
-      soundStop(w.musicSound)
+      io.soundStop(w.musicSound)
-      soundPlay(w.overSound, 1.0)
+      io.soundPlay(w.overSound, 1.0)
     else
-      soundPlay(w.hitSound, 1.0)
+      io.soundPlay(w.hitSound, 1.0)
   w.state = t
-export fun draw(w: World) =
+export fun draw(io: Io, w: World) =
+  s := w.state
-  clear(Color.rgb(0.04, 0.05, 0.1))
+  io.clear(Color.rgb(0.04, 0.05, 0.1))
-  Picture.draw(view(w.state))
+  Picture.draw(io, s.render())
 # --- tests ---
@@ -572,46 +497,30 @@ fun near(a: Float, b: Float) -> Bool =
   {a - b}.abs() < 0.01
 fun tickOf(s: State, ax: Float, ay: Float, dt: Float) -> State =
-  step(s, Tick(dt: dt, ax: ax, ay: ay))
+  s.update(Tick(dt: dt, ax: ax, ay: ay))
 fun away() -> Motion =
   Motion(x: 5000.0, y: 0.0, vx: 0.0, vy: 0.0)
+fun newState(seed: Int) -> State =
+  State.start(seed, 0, -1, -1, Rules.ArenaW, Rules.ArenaH)
 fun withOrb(s: State, i: Int, m: Motion) -> State =
-  n := State(..s)
-  n.orbs = replaceNth(s.orbs, i, orbAt(Id.Orb + i, Float(i) * 0.1, 0.0, m))
+  State(..s, orbs: s.orbs.map(|o| if o.id == Id.Orb + i then Orb(id: o.id, at: m, phase: Float(i) * 0.1, clock: 0.0) else o))
-  n
 fun withMine(s: State, i: Int, m: Motion) -> State =
-  n := State(..s)
-  n.mines = replaceNth(s.mines, i, mineAt(Id.Mine + i, 0.0, 2.0, 0.0, m))
+  State(..s, mines: s.mines.map(|k| if k.id == Id.Mine + i then Mine(id: k.id, at: m, rotation: 0.0, spin: 2.0, clock: 0.0) else k))
-  n
 # A state with the orbs and mines moved out of the way.
 fun emptyState() -> State =
-  s := newState(7, 0, -1, -1, Rules.ArenaW, Rules.ArenaH)
-  for i := range Rules.OrbCount
-    s = withOrb(s, i, away())
-  for i := range lenLink(s.mines)
-    s = withMine(s, i, away())
+  s := newState(7)
-  s
-fun orbN(s: State, i: Int) -> Orb =
-  nthOr(s.orbs, i, orbAt(0, 0.0, 0.0, away()))
-fun mineN(s: State, i: Int) -> Mine =
-  nthOr(s.mines, i, mineAt(0, 0.0, 0.0, 0.0, away()))
+  State(..s, orbs: s.orbs.map(|o| o.moved(away())), mines: s.mines.map(|k| k.moved(away())))
 fun onShip(s: State) -> Motion =
   Motion(x: s.ship.x, y: s.ship.y, vx: 0.0, vy: 0.0)
 fun forceOver(s: State) -> State =
-  n := State(..s)
-  n.lives = 0
-  n.over = true
-  n.overAt = s.clock
-  n.best = s.best.max(s.score)
+  State(..s, lives: 0, over: true, overAt: s.clock, best: s.best.max(s.score))
-  n
 fun countNodes(n: SceneNode) -> Int = match n
   Group(_, kids) => 1 + countKids(kids)
@@ -623,26 +532,26 @@ fun countKids(ks: List[SceneNode]) -> Int = match ks
   Cons(h, t) => countNodes(h) + countKids(t)
 test "steering accelerates and drag slows the ship"
-  s := shipStep(newShip(), 1.0, 0.0, 0.1)
+  s := Ship.start().update(1.0, 0.0, 0.1)
   assert s.vx > 0.0
   assert s.x > Rules.ArenaW / 2.0
   fast := s.vx
   t := s
   for i := range 30
-    t = shipStep(t, 0.0, 0.0, 0.1)
+    t = t.update(0.0, 0.0, 0.1)
   assert t.vx < fast / 4.0
 test "the ship stops at the arena walls"
-  s := ShipState(x: 20.0, y: 20.0, vx: 0.0, vy: 0.0, rotation: 0.0, hurt: 0.0)
+  s := Ship(x: 20.0, y: 20.0, vx: 0.0, vy: 0.0, rotation: 0.0, hurt: 0.0)
   for i := range 20
-    s = shipStep(s, -1.0, -1.0, 0.1)
+    s = s.update(-1.0, -1.0, 0.1)
   assert s.x == Rules.ShipRadius
   assert s.y == Rules.ShipRadius
   assert s.vx == 0.0
 test "shipStep leaves its input unchanged"
-  s := newShip()
+  s := Ship.start()
-  _ := shipStep(s, 1.0, 1.0, 0.1)
+  _ := s.update(1.0, 1.0, 0.1)
   assert s.vx == 0.0
   assert s.x == Rules.ArenaW / 2.0
@@ -650,24 +559,24 @@ test "drifters bounce off the walls"
   b := driftOf(Motion(x: 795.0, y: 300.0, vx: 100.0, vy: 0.0), Rules.OrbRadius, 0.1)
   assert b.vx == -100.0
   assert b.x == Rules.ArenaW - 10.0
-  orb := orbMove(orbAt(Id.Orb, 0.0, 0.0, Motion(x: 795.0, y: 300.0, vx: 100.0, vy: 0.0)), 0.1)
+  orb := Orb(id: Id.Orb, at: Motion(x: 795.0, y: 300.0, vx: 100.0, vy: 0.0), phase: 0.0, clock: 0.0).update(0.1)
-  assert near(orb.x, Rules.ArenaW - 10.0)
+  assert near(orb.at.x, Rules.ArenaW - 10.0)
 test "a mine spins as it drifts"
-  mine := mineAt(Id.Mine, 0.0, 2.0, 0.0, Motion(x: 400.0, y: 300.0, vx: 10.0, vy: 0.0))
+  mine := Mine(id: Id.Mine, at: Motion(x: 400.0, y: 300.0, vx: 10.0, vy: 0.0), rotation: 0.0, spin: 2.0, clock: 0.0)
-  next := mineMove(mine, 0.5)
+  next := mine.update(0.5)
   assert near(next.rotation, 1.0)
-  assert near(next.x, 405.0)
+  assert near(next.at.x, 405.0)
   assert near(mine.rotation, 0.0)
 test "collecting an orb scores and respawns it elsewhere"
   s := withOrb(emptyState(), 0, onShip(emptyState()))
   t := tickOf(s, 0.0, 0.0, 0.016)
-  orb := orbN(t, 0)
+  orb := t.orbs.at(0)
   assert t.score == Rules.OrbPoints
-  assert Math.hypot(orb.x - t.ship.x, orb.y - t.ship.y) >= 120.0
+  assert Math.hypot(orb.at.x - t.ship.x, orb.at.y - t.ship.y) >= 120.0
-  assert orb.x < 5000.0
+  assert orb.at.x < 5000.0
-  assert lenLink(t.orbs) == Rules.OrbCount
+  assert t.orbs.length() == Rules.OrbCount
 test "a mine costs one life and makes the ship flash"
   e := emptyState()
@@ -680,14 +589,14 @@ test "a mine costs one life and makes the ship flash"
   shown := 0
   for i := range 100
     t = tickOf(t, 0.0, 0.0, 0.016)
-    if countNodes(shipView(t)) == 1
+    if countNodes(t.renderShip()) == 1
       hidden = hidden + 1
     else
       shown = shown + 1
   assert hidden > 0
   assert shown > 0
   assert t.ship.hurt == 0.0
-  assert countNodes(shipView(t)) == 3
+  assert countNodes(t.renderShip()) == 3
   assert t.lives == Rules.StartLives - 1
 test "the ship is briefly safe after a hit"
@@ -698,80 +607,74 @@ test "the ship is briefly safe after a hit"
 test "the game ends at zero lives and then ignores steps"
   e := emptyState()
-  s := State(..e)
+  s := State(..e, lives: 1, score: 40)
-  s.lives = 1
-  s.score = 40
   t := tickOf(withMine(s, 0, onShip(s)), 0.0, 0.0, 0.016)
   assert t.over
   assert t.lives == 0
   assert t.best == 40
-  assert countNodes(shipView(t)) == 1
+  assert countNodes(t.renderShip()) == 1
   x := t.ship.x
   u := tickOf(t, 1.0, 0.0, 0.5)
   assert u.ship.x == x
 test "after game over nothing moves but the animations keep running"
   e := emptyState()
-  s := State(..e)
+  s := State(..e, lives: 1)
-  s.lives = 1
   t := tickOf(withMine(s, 0, Motion(x: s.ship.x, y: s.ship.y, vx: 10.0, vy: 0.0)), 0.0, 0.0, 0.016)
   assert t.over
-  mine := mineN(t, 0)
+  mine := t.mines.at(0)
   for i := range 10
     t = tickOf(t, 1.0, 0.0, 0.1)
-  after := mineN(t, 0)
+  after := t.mines.at(0)
-  assert after.x == mine.x
+  assert after.at.x == mine.at.x
   assert after.rotation == mine.rotation
   assert t.ship.x == Rules.ArenaW / 2.0
   assert after.clock > mine.clock + 0.9
-  assert orbN(t, 0).clock > 0.9
+  assert t.orbs.at(0).clock > 0.9
   assert t.clock > 0.9
   assert t.score == 0
 test "restart resets the run and keeps the best score"
   e := emptyState()
-  s := State(..e)
-  s.score = 90
-  s = forceOver(s)
+  s := forceOver(State(..e, score: 90))
-  r := step(s, Restart(seed: 5))
+  r := s.update(Restart(seed: 5))
   assert !r.over
   assert r.score == 0
   assert r.best == 90
   assert r.lives == Rules.StartLives
   assert r.ship.x == Rules.ArenaW / 2.0
-  assert lenLink(r.mines) == mineCount(0)
+  assert r.mines.length() == mineCount(0)
-  assert countNodes(shipView(r)) == 3
+  assert countNodes(r.renderShip()) == 3
-  assert countNodes(overlayView(r)) == 1
+  assert countNodes(r.renderOverlay()) == 1
 test "more mines appear as the score grows and restart removes them"
   assert mineCount(0) == 3
   assert mineCount(100) == 5
   assert mineCount(10000) == 8
   e := emptyState()
-  s := State(..e)
+  s := State(..e, score: 100)
-  s.score = 100
   t := tickOf(s, 0.0, 0.0, 0.016)
-  assert lenLink(t.mines) == 5
+  assert t.mines.length() == 5
-  r := step(t, Restart(seed: 3))
+  r := t.update(Restart(seed: 3))
-  assert lenLink(r.mines) == 3
+  assert r.mines.length() == 3
 test "the same seed plays out the same way"
-  a := newState(11, 0, -1, -1, Rules.ArenaW, Rules.ArenaH)
+  a := newState(11)
-  b := newState(11, 0, -1, -1, Rules.ArenaW, Rules.ArenaH)
+  b := newState(11)
   for i := range 120
     a = tickOf(a, 1.0, -1.0, 0.016)
     b = tickOf(b, 1.0, -1.0, 0.016)
   assert a.ship.x == b.ship.x
   assert a.score == b.score
-  assert mineN(a, 0).x == mineN(b, 0).x
+  assert a.mines.at(0).at.x == b.mines.at(0).at.x
-  other := newState(12, 0, -1, -1, Rules.ArenaW, Rules.ArenaH)
+  other := newState(12)
-  assert orbN(other, 0).x != orbN(a, 0).x
+  assert other.orbs.at(0).at.x != a.orbs.at(0).at.x
 test "fit centres the arena on the screen"
-  s := step(emptyState(), Resize(w: 1600.0, h: 600.0))
+  s := emptyState().update(Resize(w: 1600.0, h: 600.0))
-  assert near(zoomOf(s), 1.0)
+  assert near(s.zoom(), 1.0)
-  assert near(offsetX(s), 400.0)
+  assert near(s.offsetX(), 400.0)
-  assert near(offsetY(s), 0.0)
+  assert near(s.offsetY(), 0.0)
 test "animation frames cycle"
   assert frameOf(0.0, 4, 8.0) == 0
@@ -782,21 +685,21 @@ test "animation frames cycle"
 test "restart_button_hidden_while_playing"
   s := emptyState()
-  assert !onRestart(s, 400.0, 364.0)
+  assert !s.onRestart(400.0, 364.0)
 test "restart_button_click_restarts"
   s := forceOver(emptyState())
-  assert onRestart(s, 400.0, 364.0)
+  assert s.onRestart(400.0, 364.0)
-  assert !onRestart(s, 100.0, 100.0)
+  assert !s.onRestart(100.0, 100.0)
-  assert !onRestart(s, 400.0, 260.0)
+  assert !s.onRestart(400.0, 260.0)
-  r := step(s, Restart(seed: 9))
+  r := s.update(Restart(seed: 9))
   assert !r.over
-  assert !onRestart(r, 400.0, 364.0)
+  assert !r.onRestart(400.0, 364.0)
 test "the restart button is found through the camera"
-  s := step(forceOver(emptyState()), Resize(w: 1600.0, h: 600.0))
+  s := forceOver(emptyState()).update(Resize(w: 1600.0, h: 600.0))
-  assert onRestart(s, 800.0, 364.0)
+  assert s.onRestart(800.0, 364.0)
-  assert !onRestart(s, 400.0, 364.0)
+  assert !s.onRestart(400.0, 364.0)
 test "update_is_pure"
   s := emptyState()
@@ -809,49 +712,47 @@ test "freezing at game over keeps the orb and mine animation clocks"
   t := emptyState()
   for i := range 5
     t = tickOf(t, 0.0, 0.0, 0.1)
-  orbClock := orbN(t, 0).clock
+  orbClock := t.orbs.at(0).clock
-  mineClock := mineN(t, 0).clock
+  mineClock := t.mines.at(0).clock
   assert orbClock > 0.4
-  t.lives = 1
+  t = State(..t, lives: 1)
   t = tickOf(withMine(t, 1, onShip(t)), 0.0, 0.0, 0.1)
   assert t.over
-  assert orbN(t, 0).clock > orbClock
+  assert t.orbs.at(0).clock > orbClock
-  assert mineN(t, 0).clock > mineClock
+  assert t.mines.at(0).clock > mineClock
 test "view_is_pure"
   s := emptyState()
-  a := countNodes(view(s))
+  a := countNodes(s.render())
-  b := countNodes(view(s))
+  b := countNodes(s.render())
   assert a == b
-  ba := Picture.bounds(view(s))
+  ba := Picture.bounds(s.render())
-  bb := Picture.bounds(view(s))
+  bb := Picture.bounds(s.render())
   assert ba.x == bb.x
   assert ba.w == bb.w
   assert s.clock == 0.0
 test "view_node_count"
-  s := newState(7, 0, -1, -1, Rules.ArenaW, Rules.ArenaH)
+  s := newState(7)
-  assert countNodes(view(s)) == 79
+  assert countNodes(s.render()) == 79
   over := forceOver(s)
-  assert countNodes(overlayView(over)) > 5
+  assert countNodes(over.renderOverlay()) > 5
-  assert countNodes(view(over)) > countNodes(view(s)) - 3
+  assert countNodes(over.render()) > countNodes(s.render()) - 3
 test "restart_click_through_ui"
   e := emptyState()
-  s := State(..e)
-  s.score = 90
-  s = forceOver(s)
+  s := forceOver(State(..e, score: 90))
-  down := feed(s, UiInput(kind: PointerDown, x: 400.0, y: 364.0))
+  down := s.feed(UiInput(kind: PointerDown, x: 400.0, y: 364.0))
   assert down.over
   assert Ui.pressed(down.ui, Id.Restart)
-  up := feed(down, UiInput(kind: PointerUp, x: 400.0, y: 364.0))
+  up := down.feed(UiInput(kind: PointerUp, x: 400.0, y: 364.0))
   assert !up.over
   assert up.score == 0
   assert up.best == 90
   assert up.lives == Rules.StartLives
-  off := feed(feed(s, UiInput(kind: PointerDown, x: 400.0, y: 364.0)), UiInput(kind: PointerUp, x: 100.0, y: 100.0))
+  off := s.feed(UiInput(kind: PointerDown, x: 400.0, y: 364.0)).feed(UiInput(kind: PointerUp, x: 100.0, y: 100.0))
   assert off.over
-  miss := feed(feed(s, UiInput(kind: PointerDown, x: 100.0, y: 100.0)), UiInput(kind: PointerUp, x: 100.0, y: 100.0))
+  miss := s.feed(UiInput(kind: PointerDown, x: 100.0, y: 100.0)).feed(UiInput(kind: PointerUp, x: 100.0, y: 100.0))
   assert miss.over
 test "hit_flash_pose_at_fixed_times"

plum-examples/games/imperative/game.plum CHANGED Viewed

@@ -34,19 +34,19 @@ primitive Rules =
   Zoom = 3.0
 # A moving circle. `angle` is the ship's heading or a mine's spin, in radians clockwise.
-record Body(x: Float, y: Float, vx: Float, vy: Float, angle: Float)
+record Body(mut x: Float, mut y: Float, mut vx: Float, mut vy: Float, mut angle: Float)
 record World(
   ship: Body,
   orbs: Slice[Body],
   mines: Slice[Body],
-  rng: Random,
+  mut rng: Random,
-  score: Int,
+  mut score: Int,
-  best: Int,
+  mut best: Int,
-  lives: Int,
+  mut lives: Int,
-  hurt: Float,
+  mut hurt: Float,
-  clock: Float,
+  mut clock: Float,
-  over: Bool,
+  mut over: Bool,
   sheet: Int,
   pickupSound: Int,
   hitSound: Int,
@@ -54,16 +54,19 @@ record World(
   musicSound: Int) =
   fun create(seed: Int, sheet: Int) -> 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: Slice[Body](), mines: Slice[Body](), rng: rng, score: 0, best: 0,
+      ship: ship, orbs: Slice[Body](), mines: Slice[Body](), rng: Random.seeded(seed), 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
-      w.orbs.push(spawn(rng, ship, 120.0, 40.0))
+      sp := spawn(w.rng, ship, 120.0, 40.0)
+      w.rng = sp.rng
+      w.orbs.push(sp.at)
     for i := range mineCount(0)
-      w.mines.push(spawn(rng, ship, 220.0, 90.0))
+      sp := spawn(w.rng, ship, 220.0, 90.0)
+      w.rng = sp.rng
+      w.mines.push(sp.at)
     w
   # A world with the orbs and mines moved out of the way.
@@ -91,7 +94,9 @@ record World(
     self.ship.vx = 0.0
     self.ship.vy = 0.0
     for i := range self.orbs.length()
-      moved := spawn(self.rng, self.ship, 120.0, 40.0)
+      sp := spawn(self.rng, self.ship, 120.0, 40.0)
+      self.rng = sp.rng
+      moved := sp.at
       self.orbs.at(i).x = moved.x
       self.orbs.at(i).y = moved.y
       self.orbs.at(i).vx = moved.vx
@@ -99,7 +104,9 @@ record World(
     while self.mines.length() > mineCount(0)
       _ := self.mines.pop()!
     for i := range self.mines.length()
-      moved := spawn(self.rng, self.ship, 220.0, 90.0)
+      sp := spawn(self.rng, self.ship, 220.0, 90.0)
+      self.rng = sp.rng
+      moved := sp.at
       self.mines.at(i).x = moved.x
       self.mines.at(i).y = moved.y
       self.mines.at(i).vx = moved.vx
@@ -117,13 +124,17 @@ record World(
       drift(orb, Rules.OrbRadius, dt)
       if overlaps(self.ship, Rules.ShipRadius, orb, Rules.OrbRadius)
         self.score = self.score + Rules.OrbPoints
-        moved := spawn(self.rng, self.ship, 120.0, 40.0)
+        sp := spawn(self.rng, self.ship, 120.0, 40.0)
+        self.rng = sp.rng
+        moved := sp.at
         orb.x = moved.x
         orb.y = moved.y
         orb.vx = moved.vx
         orb.vy = moved.vy
     while self.mines.length() < mineCount(self.score)
-      self.mines.push(spawn(self.rng, self.ship, 220.0, 90.0))
+      sp := spawn(self.rng, self.ship, 220.0, 90.0)
+      self.rng = sp.rng
+      self.mines.push(sp.at)
     for i := range self.mines.length()
       mine := self.mines.at(i)
       drift(mine, Rules.MineRadius, dt)
@@ -220,21 +231,30 @@ fun frameOf(clock: Float, count: Int, fps: Float) -> Int =
   Int(clock * fps) % count
 # A body at a random spot at least `gap` away from `avoid`, drifting at up to `speed`.
+# A Body and the generator to continue from.
+record Spawned(at: Body, rng: Random)
-fun spawn(rng: Random, avoid: Body, gap: Float, speed: Float) -> Body =
+fun spawn(rng: Random, avoid: Body, gap: Float, speed: Float) -> Spawned =
   margin := 30.0
   b := Body(x: 0.0, y: 0.0, vx: 0.0, vy: 0.0, angle: 0.0)
+  r := rng
   tries := 0
   while tries < 20
+    dx := r.nextFloat()
+    dy := dx.rng.nextFloat()
+    r = dy.rng
-    b.x = margin + rng.nextFloat() * {Rules.ArenaW - 2.0 * margin}
+    b.x = margin + dx.value * {Rules.ArenaW - 2.0 * margin}
-    b.y = margin + rng.nextFloat() * {Rules.ArenaH - 2.0 * margin}
+    b.y = margin + dy.value * {Rules.ArenaH - 2.0 * margin}
     if distance(b, avoid) >= gap
       break
     tries = tries + 1
+  dh := r.nextFloat()
+  dp := dh.rng.nextFloat()
-  heading := rng.nextFloat() * Float.Tau
+  heading := dh.value * Float.Tau
-  pace := speed * {0.4 + 0.6 * rng.nextFloat()}
+  pace := speed * {0.4 + 0.6 * dp.value}
   b.vx = Math.cos(heading) * pace
   b.vy = Math.sin(heading) * pace
-  b
+  Spawned(at: b, rng: dp.rng)
 # How many mines are out: more as the score grows.
 fun mineCount(score: Int) -> Int =
@@ -282,7 +302,7 @@ fun musicVolume() -> Float =
   0.3
 export fun init(io: Io) -> World =
-  w := World.create(2024, io.textureLoad("sprites.png"))
+  w := World.create(io.randomSeed(), io.textureLoad("sprites.png"))
   w.pickupSound = io.soundLoad("pickup.wav")
   w.hitSound = io.soundLoad("hit.wav")
   w.overSound = io.soundLoad("gameover.wav")

plum-examples/{game_loop.plum → games/imperative/game_loop.plum} RENAMED Viewed

@@ -19,7 +19,7 @@ struct Vec2(x: Float, y: Float) =
 struct Particle(pos: Vec2, vel: Vec2, life: Int)
-record Entity(id: Int, name: Str, hp: Int)
+record Entity(id: Int, name: Str, mut hp: Int)
 record Spawn(id: Int, name: Str)

plum-examples/games/imperative/game_scene.plum CHANGED Viewed

@@ -49,28 +49,37 @@ primitive Rules =
   Zoom = 3.0
 # A position and velocity: what a spawn returns and what drifters are bounced with.
-record Motion(x: Float, y: Float, vx: Float, vy: Float)
+record Motion(mut x: Float, mut y: Float, mut vx: Float, mut vy: Float)
 # Which of `count` animation frames is showing after `clock` seconds at `fps` frames per second.
 fun frameOf(clock: Float, count: Int, fps: Float) -> Int =
   Int(clock * fps) % count
 # A random spot at least `gap` away from (ax, ay), drifting at up to `speed`.
+# A Motion and the generator to continue from.
+record Spawned(at: Motion, rng: Random)
-fun spawn(rng: Random, ax: Float, ay: Float, gap: Float, speed: Float) -> Motion =
+fun spawn(rng: Random, ax: Float, ay: Float, gap: Float, speed: Float) -> Spawned =
   margin := 30.0
   b := Motion(x: 0.0, y: 0.0, vx: 0.0, vy: 0.0)
+  r := rng
   tries := 0
   while tries < 20
+    dx := r.nextFloat()
+    dy := dx.rng.nextFloat()
+    r = dy.rng
-    b.x = margin + rng.nextFloat() * {Rules.ArenaW - 2.0 * margin}
+    b.x = margin + dx.value * {Rules.ArenaW - 2.0 * margin}
-    b.y = margin + rng.nextFloat() * {Rules.ArenaH - 2.0 * margin}
+    b.y = margin + dy.value * {Rules.ArenaH - 2.0 * margin}
     if Math.hypot(b.x - ax, b.y - ay) >= gap
       break
     tries = tries + 1
+  dh := r.nextFloat()
+  dp := dh.rng.nextFloat()
-  heading := rng.nextFloat() * Float.Tau
+  heading := dh.value * Float.Tau
-  pace := speed * {0.4 + 0.6 * rng.nextFloat()}
+  pace := speed * {0.4 + 0.6 * dp.value}
   b.vx = Math.cos(heading) * pace
   b.vy = Math.sin(heading) * pace
-  b
+  Spawned(at: b, rng: dp.rng)
 # Moves a drifter and bounces it off the arena walls.
 fun drift(b: Motion, r: Float, dt: Float) =
@@ -91,20 +100,13 @@ fun mineCount(score: Int) -> Int =
 # (origin at the middle of the box, so `rotation` turns it about its centre).
 # The player. `ax` and `ay` are the input axes (-1..1) for the next `act`.
-record Ship(Actor(x, y), tex: Int) =
+record Ship(Actor(x, y), tex: Int, mut vx: Float, mut vy: Float, mut ax: Float, mut ay: Float, mut hurt: Float, mut clock: Float, mut live: Bool) =
   fun init(self) =
     self.width = Rules.Cell * Rules.Zoom
     self.height = self.width
     self.originX = self.width / 2.0
     self.originY = self.height / 2.0
-    self.vx = 0.0
-    self.vy = 0.0
-    self.ax = 0.0
-    self.ay = 0.0
-    self.hurt = 0.0
-    self.clock = 0.0
-    self.live = true
   # Accelerates by the input axes, applies drag, keeps the ship in the arena and
   # blinks it while it is hurt (the blink is just `visible`).
@@ -144,18 +146,16 @@ record Ship(Actor(x, y), tex: Int) =
     drawSpriteFrame(io, m, alpha, self.width, self.height, self.color, self.tex, frame * Rules.Cell, 0.0, Rules.Cell, Rules.Cell)
 # A glowing orb drifting about. `phase` offsets its animation from the other orbs.
-record Orb(Actor(x, y), vx: Float, vy: Float, phase: Float, tex: Int) =
+record Orb(Actor(x, y), mut vx: Float, mut vy: Float, phase: Float, tex: Int, mut clock: Float, mut live: Bool) =
   fun init(self) =
     self.width = Rules.Cell * Rules.Zoom
     self.height = self.width
     self.originX = self.width / 2.0
     self.originY = self.height / 2.0
-    self.clock = 0.0
-    self.live = true
   fun create(sheet: Int, phase: Float, at: Motion) -> Orb =
-    Orb(x: at.x, y: at.y, vx: at.vx, vy: at.vy, phase: phase, tex: sheet)
+    Orb(x: at.x, y: at.y, vx: at.vx, vy: at.vy, phase: phase, tex: sheet, clock: 0.0, live: true)
   fun motion(self) -> Motion =
     Motion(x: self.x, y: self.y, vx: self.vx, vy: self.vy)
@@ -185,18 +185,16 @@ record Orb(Actor(x, y), vx: Float, vy: Float, phase: Float, tex: Int) =
     drawSpriteFrame(io, m, alpha, self.width, self.height, self.color, self.tex, frame * Rules.Cell, Rules.Cell, Rules.Cell, Rules.Cell)
 # A spinning mine drifting about.
-record Mine(Actor(x, y), vx: Float, vy: Float, tex: Int) =
+record Mine(Actor(x, y), mut vx: Float, mut vy: Float, tex: Int, mut clock: Float, mut live: Bool) =
   fun init(self) =
     self.width = Rules.Cell * Rules.Zoom
     self.height = self.width
     self.originX = self.width / 2.0
     self.originY = self.height / 2.0
-    self.clock = 0.0
-    self.live = true
   fun create(sheet: Int, at: Motion) -> Mine =
-    Mine(x: at.x, y: at.y, vx: at.vx, vy: at.vy, tex: sheet)
+    Mine(x: at.x, y: at.y, vx: at.vx, vy: at.vy, tex: sheet, clock: 0.0, live: true)
   fun motion(self) -> Motion =
     Motion(x: self.x, y: self.y, vx: self.vx, vy: self.vy)
@@ -221,16 +219,13 @@ record Mine(Actor(x, y), vx: Float, vy: Float, tex: Int) =
     drawSpriteFrame(io, m, alpha, self.width, self.height, self.color, self.tex, frame * Rules.Cell, 2.0 * Rules.Cell, Rules.Cell, Rules.Cell)
 # A background star that twinkles.
-record Star(Actor(x, y, width, height), seed: Float) =
+record Star(Actor(x, y, width, height), seed: Float, mut clock: Float) =
-  fun init(self) =
-    self.clock = 0.0
   fun create(i: Int) -> Star =
     r := 1.0 + Float(i % 3) * 0.5
     Star(
       x: Float({i * 7919} % 800) - r, y: Float({i * 104729} % 600) - r, width: r * 2.0,
-      height: r * 2.0, seed: Float(i))
+      height: r * 2.0, seed: Float(i), clock: 0.0)
   override fun act(self, dt: Float) =
     self.clock = self.clock + dt
@@ -243,7 +238,7 @@ record Star(Actor(x, y, width, height), seed: Float) =
 # touch, and the run's state. `mines` and `orbs` are the layer Groups; `mineList`
 # and `orbList` are the same actors, typed.
 record World(
-  Stage(camScale),
+  Stage(camX, camY, camScale),
   ship: Ship,
   mines: Group,
   orbs: Group,
@@ -253,12 +248,12 @@ record World(
   scoreText: Text,
   bestText: Text,
   lifeIcons: Slice[Sprite],
-  rng: Random,
+  mut rng: Random,
-  score: Int,
+  mut score: Int,
-  best: Int,
+  mut best: Int,
-  lives: Int,
+  mut lives: Int,
-  over: Bool,
+  mut over: Bool,
-  clock: Float,
+  mut clock: Float,
   sheet: Int,
   pickupSound: Int,
   hitSound: Int,
@@ -266,8 +261,7 @@ record World(
   musicSound: Int) =
   fun create(seed: Int, sheet: Int) -> World =
-    rng := Random(seed: seed)
-    ship := Ship(x: Rules.ArenaW / 2.0, y: Rules.ArenaH / 2.0, tex: sheet)
+    ship := Ship(x: Rules.ArenaW / 2.0, y: Rules.ArenaH / 2.0, tex: sheet, vx: 0.0, vy: 0.0, ax: 0.0, ay: 0.0, hurt: 0.0, clock: 0.0, live: true)
     stars := Group()
     for i := range 40
       stars.add(Star.create(i))
@@ -296,9 +290,9 @@ 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: Slice[Mine](), orbList: Slice[Orb](),
+      camX: 0.0, camY: 0.0, 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,
+      rng: Random.seeded(seed), score: 0, best: 0, lives: Rules.StartLives, over: false, clock: 0.0, sheet: sheet,
       pickupSound: -1, hitSound: -1, overSound: -1, musicSound: -1)
     w.root.add(Rect.create(Rules.ArenaW, Rules.ArenaH, Color.rgb(0.07, 0.08, 0.16)))
     w.root.add(stars)
@@ -307,7 +301,9 @@ record World(
     w.root.add(ship)
     w.root.add(hud)
     for i := range Rules.OrbCount
+      sp := spawn(w.rng, ship.x, ship.y, 120.0, 40.0)
+      w.rng = sp.rng
-      orb := Orb.create(sheet, Float(i) * 0.1, spawn(rng, ship.x, ship.y, 120.0, 40.0))
+      orb := Orb.create(sheet, Float(i) * 0.1, sp.at)
       orbs.add(orb)
       w.orbList.push(orb)
     for i := range mineCount(0)
@@ -325,7 +321,9 @@ record World(
   # Adds one mine, far from the ship, to the mines layer.
   fun addMine(self) =
-    mine := Mine.create(self.sheet, spawn(self.rng, self.ship.x, self.ship.y, 220.0, 90.0))
+    sp := spawn(self.rng, self.ship.x, self.ship.y, 220.0, 90.0)
+    self.rng = sp.rng
+    mine := Mine.create(self.sheet, sp.at)
     self.mines.add(mine)
     self.mineList.push(mine)
@@ -343,12 +341,16 @@ record World(
     ship.vx = 0.0
     ship.vy = 0.0
     for i := range self.orbList.length()
-      self.orbList.at(i).place(spawn(self.rng, ship.x, ship.y, 120.0, 40.0))
+      sp := spawn(self.rng, ship.x, ship.y, 120.0, 40.0)
+      self.rng = sp.rng
+      self.orbList.at(i).place(sp.at)
     while self.mineList.length() > mineCount(0)
       gone := self.mineList.pop()!
       self.mines.remove(gone)
     for i := range self.mineList.length()
-      self.mineList.at(i).place(spawn(self.rng, ship.x, ship.y, 220.0, 90.0))
+      sp := spawn(self.rng, ship.x, ship.y, 220.0, 90.0)
+      self.rng = sp.rng
+      self.mineList.at(i).place(sp.at)
     self.sync()
   # Copies the score, best score, lives and game-over panel into the HUD actors.
@@ -382,7 +384,9 @@ record World(
       orb := self.orbList.at(i)
       if overlaps(ship.x, ship.y, Rules.ShipRadius, orb.x, orb.y, Rules.OrbRadius)
         self.score = self.score + Rules.OrbPoints
-        orb.place(spawn(self.rng, ship.x, ship.y, 120.0, 40.0))
+        sp := spawn(self.rng, ship.x, ship.y, 120.0, 40.0)
+        self.rng = sp.rng
+        orb.place(sp.at)
     while self.mineList.length() < mineCount(self.score)
       self.addMine()
     for i := range self.mineList.length()
@@ -442,7 +446,7 @@ fun musicVolume() -> Float =
   0.3
 export fun init(io: Io) -> World =
-  w := World.create(2024, io.textureLoad("sprites.png"))
+  w := World.create(io.randomSeed(), io.textureLoad("sprites.png"))
   w.pickupSound = io.soundLoad("pickup.wav")
   w.hitSound = io.soundLoad("hit.wav")
   w.overSound = io.soundLoad("gameover.wav")
@@ -470,7 +474,7 @@ fun near(a: Float, b: Float) -> Bool =
   {a - b}.abs() < 0.01
 test "steering accelerates and drag slows the ship"
-  ship := Ship(x: 400.0, y: 300.0, tex: -1)
+  ship := Ship(x: 400.0, y: 300.0, tex: -1, vx: 0.0, vy: 0.0, ax: 0.0, ay: 0.0, hurt: 0.0, clock: 0.0, live: true)
   ship.ax = 1.0
   ship.act(0.1)
   assert ship.vx > 0.0
@@ -482,7 +486,7 @@ test "steering accelerates and drag slows the ship"
   assert ship.vx < fast / 4.0
 test "the ship stops at the arena walls"
-  ship := Ship(x: 20.0, y: 20.0, tex: -1)
+  ship := Ship(x: 20.0, y: 20.0, tex: -1, vx: 0.0, vy: 0.0, ax: 0.0, ay: 0.0, hurt: 0.0, clock: 0.0, live: true)
   ship.ax = -1.0
   ship.ay = -1.0
   for i := range 20

plum-examples/games/imperative/scene.plum CHANGED Viewed

@@ -48,7 +48,7 @@ record Orbit(Actor, speed: Float) =
     self.actChildren(dt)
 # A sprite that turns on its own axis, `speed` radians per second.
-record Spinner(Actor(width, height, originX, originY), speed: Float, tex: Int, srcX: Float, srcY: Float) =
+record Spinner(Actor(width, height, originX, originY), speed: Float, tex: Int, mut srcX: Float, srcY: Float) =
   fun init(self) =
     self.srcW: Float = Layout.Cell
@@ -98,10 +98,10 @@ record Sky(
   sun: Spinner,
   label: Text,
   crowd: Group,
-  front: Actor?,
+  mut front: Actor?,
-  selected: Int,
+  mut selected: Int,
-  clock: Float,
+  mut clock: Float,
-  paused: Bool,
+  mut paused: Bool,
   map: Int)
 # A body sprite and its (hidden) halo in a group `slot` centred on the group's own
@@ -273,12 +273,11 @@ record ProbeSpinner(Actor) =
     self.actChildren(dt)
 # A walker: moves along x in its own `act` and counts the frames it draws itself in.
-record ProbeWalker(Actor, speed: Float) =
+record ProbeWalker(Actor, speed: Float, mut drawn: Int) =
   fun init(self) =
     self.width = 10.0
     self.height = 10.0
-    self.drawn = 0
   override fun act(self, dt: Float) =
     self.x = self.x + self.speed * dt
@@ -399,7 +398,7 @@ test "act runs behaviours depth first, including invisible actors"
 test "walker_record: a Walker in a Stage moves via its own act and draws via its own draw"
   stage := Stage.create()
-  w := ProbeWalker(speed: 4.0)
+  w := ProbeWalker(speed: 4.0, drawn: 0)
   stage.root.add(w)
   stage.root.add(Group())
   stage.act(0.5)

plum-examples/games/pure/game_pure_scene.plum CHANGED Viewed

@@ -29,6 +29,7 @@ import std/game/pure/Actions
 import std/game/pure/PureScene
 import std/game/pure/SceneTree
 import std/game/pure/SceneInput
+import std/Io
 primitive Rules =
   ArenaW = 800.0
@@ -75,34 +76,43 @@ fun frameOf(clock: Float, count: Int, fps: Float) -> Int =
   Int(clock * fps) % count
 # A random spot at least `gap` away from (ax, ay), drifting at up to `speed`.
+# A Motion and the generator to continue from.
+record Spawned(at: Motion, rng: Random)
-fun spawn(rng: Random, ax: Float, ay: Float, gap: Float, speed: Float) -> Motion =
+fun spawn(rng: Random, ax: Float, ay: Float, gap: Float, speed: Float) -> Spawned =
   margin := 30.0
-  b := Motion(x: 0.0, y: 0.0, vx: 0.0, vy: 0.0)
+  bx := 0.0
+  by := 0.0
+  r := rng
   tries := 0
   while tries < 20
+    dx := r.nextFloat()
+    dy := dx.rng.nextFloat()
+    r = dy.rng
-    b.x = margin + rng.nextFloat() * {Rules.ArenaW - 2.0 * margin}
+    bx = margin + dx.value * {Rules.ArenaW - 2.0 * margin}
-    b.y = margin + rng.nextFloat() * {Rules.ArenaH - 2.0 * margin}
+    by = margin + dy.value * {Rules.ArenaH - 2.0 * margin}
-    if Math.hypot(b.x - ax, b.y - ay) >= gap
+    if Math.hypot(bx - ax, by - ay) >= gap
       break
     tries = tries + 1
+  dh := r.nextFloat()
+  dp := dh.rng.nextFloat()
-  heading := rng.nextFloat() * Float.Tau
+  heading := dh.value * Float.Tau
-  pace := speed * {0.4 + 0.6 * rng.nextFloat()}
+  pace := speed * {0.4 + 0.6 * dp.value}
-  b.vx = Math.cos(heading) * pace
-  b.vy = Math.sin(heading) * pace
+  Spawned(at: Motion(x: bx, y: by, vx: Math.cos(heading) * pace, vy: Math.sin(heading) * pace), rng: dp.rng)
-  b
 # `b` moved for `dt` seconds and bounced off the arena walls; `b` itself is unchanged.
 fun driftOf(b: Motion, r: Float, dt: Float) -> Motion =
-  n := Motion(..b)
-  n.x = b.x + b.vx * dt
+  x := b.x + b.vx * dt
-  n.y = b.y + b.vy * dt
+  y := b.y + b.vy * dt
+  vx := b.vx
+  vy := b.vy
-  if n.x < r || n.x > Rules.ArenaW - r
+  if x < r || x > Rules.ArenaW - r
-    n.vx = 0.0 - b.vx
+    vx = 0.0 - b.vx
-    n.x = n.x.max(r).min(Rules.ArenaW - r)
+    x = x.max(r).min(Rules.ArenaW - r)
-  if n.y < r || n.y > Rules.ArenaH - r
+  if y < r || y > Rules.ArenaH - r
-    n.vy = 0.0 - b.vy
+    vy = 0.0 - b.vy
-    n.y = n.y.max(r).min(Rules.ArenaH - r)
+    y = y.max(r).min(Rules.ArenaH - r)
-  n
+  Motion(x: x, y: y, vx: vx, vy: vy)
 # How many mines are out: more as the score grows.
 fun mineCount(score: Int) -> Int =
@@ -113,31 +123,29 @@ record ShipState(x: Float, y: Float, vx: Float, vy: Float, rotation: Float, hurt
 # Accelerates by the input axes, applies drag and keeps the ship in the arena.
 fun shipStep(s: ShipState, ax: Float, ay: Float, dt: Float) -> ShipState =
-  n := ShipState(..s)
-  n.hurt = {s.hurt - dt}.max(0.0)
+  hurt := {s.hurt - dt}.max(0.0)
-  n.vx = s.vx + ax * Rules.Thrust * dt
-  n.vy = s.vy + ay * Rules.Thrust * dt
   keep := {1.0 - Rules.Drag * dt}.max(0.0)
-  n.vx = n.vx * keep
+  vx := {s.vx + ax * Rules.Thrust * dt} * keep
-  n.vy = n.vy * keep
+  vy := {s.vy + ay * Rules.Thrust * dt} * keep
-  n.x = s.x + n.vx * dt
+  x := s.x + vx * dt
-  n.y = s.y + n.vy * dt
+  y := s.y + vy * dt
   r := Rules.ShipRadius
-  if n.x < r
+  if x < r
-    n.x = r
+    x = r
-    n.vx = 0.0
+    vx = 0.0
-  if n.x > Rules.ArenaW - r
+  if x > Rules.ArenaW - r
-    n.x = Rules.ArenaW - r
+    x = Rules.ArenaW - r
-    n.vx = 0.0
+    vx = 0.0
-  if n.y < r
+  if y < r
-    n.y = r
+    y = r
-    n.vy = 0.0
+    vy = 0.0
-  if n.y > Rules.ArenaH - r
+  if y > Rules.ArenaH - r
-    n.y = Rules.ArenaH - r
+    y = Rules.ArenaH - r
-    n.vy = 0.0
+    vy = 0.0
+  rotation := s.rotation
-  if n.vx * n.vx + n.vy * n.vy > 400.0
+  if vx * vx + vy * vy > 400.0
-    n.rotation = Math.atan2(n.vx, 0.0 - n.vy)
+    rotation = Math.atan2(vx, 0.0 - vy)
-  n
+  ShipState(x: x, y: y, vx: vx, vy: vy, rotation: rotation, hurt: hurt)
 fun newShip() -> ShipState =
   ShipState(x: Rules.ArenaW / 2.0, y: Rules.ArenaH / 2.0, vx: 0.0, vy: 0.0, rotation: 0.0, hurt: 0.0)
@@ -157,34 +165,31 @@ record Panel(Actor) =
   fun create(id: Int, x: Float, y: Float, w: Float, h: Float, c: Color) -> Node =
     n := PureScene.custom(id, x, y, w, h, Panel())
-    n.color = c
+    Node(..n, color: c)
-    n
-  override fun draw(self, n: Node, m: Affine, tint: Color) =
+  override fun draw(self, io: Io, n: Node, m: Affine, tint: Color) =
     p := m.apply(Vec2(x: 0.0, y: 0.0))
-    drawRect(p.x, p.y, n.width * m.scaleX(), n.height * m.scaleY(), tint)
+    io.drawRect(p.x, p.y, n.width * m.scaleX(), n.height * m.scaleY(), tint)
 # The player: only a picture that follows `ShipState`; `act` runs its animation clock.
-record Ship(Actor, clock: Float, tex: Int) =
+record Ship(Actor, mut clock: Float, tex: Int) =
   fun create(sheet: Int, s: ShipState) -> Node =
     n := PureScene.custom(Id.Ship, s.x - Rules.Half, s.y - Rules.Half, Rules.Size, Rules.Size, Ship(clock: 0.0, tex: sheet))
-    n.originX = Rules.Half
+    Node(..n, originX: Rules.Half, originY: Rules.Half)
-    n.originY = Rules.Half
-    n
-  override fun act(self, own n: Node, dt: Float) -> Node =
+  override fun act(self, n: Node, dt: Float) -> Node =
     self.clock = self.clock + dt
     n
-  override fun draw(self, n: Node, m: Affine, tint: Color) =
+  override fun draw(self, io: Io, n: Node, m: Affine, tint: Color) =
     c := m.apply(Vec2(x: n.width / 2.0, y: n.height / 2.0))
-    drawCircle(c.x, c.y, 17.0 * m.scaleX(), Color(r: 0.4, g: 0.8, b: 1.0, a: 0.12 * tint.a))
+    io.drawCircle(c.x, c.y, 17.0 * m.scaleX(), Color(r: 0.4, g: 0.8, b: 1.0, a: 0.12 * tint.a))
     frame := Float(frameOf(self.clock, 4, 14.0))
-    pureDrawSprite(m, tint, n.width, n.height, self.tex, frame * Rules.Cell, 0.0, Rules.Cell, Rules.Cell)
+    pureDrawSprite(io, m, tint, n.width, n.height, self.tex, frame * Rules.Cell, 0.0, Rules.Cell, Rules.Cell)
 # A glowing orb drifting about. `phase` offsets its animation from the other orbs.
-record Orb(Actor, vx: Float, vy: Float, phase: Float, clock: Float, tex: Int) =
+record Orb(Actor, mut vx: Float, mut vy: Float, phase: Float, mut clock: Float, tex: Int) =
   fun create(sheet: Int, phase: Float, id: Int, at: Motion) -> Node =
     Orb.createAt(sheet, phase, id, at, 0.0)
@@ -193,31 +198,27 @@ record Orb(Actor, vx: Float, vy: Float, phase: Float, clock: Float, tex: Int) =
   fun createAt(sheet: Int, phase: Float, id: Int, at: Motion, clock: Float) -> Node =
     n := PureScene.custom(id, at.x - Rules.Half, at.y - Rules.Half, Rules.Size, Rules.Size,
       Orb(vx: at.vx, vy: at.vy, phase: phase, clock: clock, tex: sheet))
-    n.originX = Rules.Half
+    Node(..n, originX: Rules.Half, originY: Rules.Half)
-    n.originY = Rules.Half
-    n
-  override fun act(self, own n: Node, dt: Float) -> Node =
+  override fun act(self, n: Node, dt: Float) -> Node =
     m := driftOf(Motion(x: n.x + Rules.Half, y: n.y + Rules.Half, vx: self.vx, vy: self.vy), Rules.OrbRadius, dt)
     self.clock = self.clock + dt
-    n.x = m.x - Rules.Half
-    n.y = m.y - Rules.Half
     self.vx = m.vx
     self.vy = m.vy
-    n
+    Node(..n, x: m.x - Rules.Half, y: m.y - Rules.Half)
-  override fun draw(self, n: Node, m: Affine, tint: Color) =
+  override fun draw(self, io: Io, n: Node, m: Affine, tint: Color) =
     c := m.apply(Vec2(x: n.width / 2.0, y: n.height / 2.0))
     k := m.scaleX()
-    blendMode(Blend.Add)
+    io.blendMode(Blend.Add)
-    drawCircle(c.x, c.y, 26.0 * k, Color(r: 0.35, g: 0.22, b: 0.0, a: 0.5 * tint.a))
+    io.drawCircle(c.x, c.y, 26.0 * k, Color(r: 0.35, g: 0.22, b: 0.0, a: 0.5 * tint.a))
-    drawCircle(c.x, c.y, 17.0 * k, Color(r: 0.6, g: 0.4, b: 0.05, a: 0.5 * tint.a))
+    io.drawCircle(c.x, c.y, 17.0 * k, Color(r: 0.6, g: 0.4, b: 0.05, a: 0.5 * tint.a))
-    blendMode(Blend.Normal)
+    io.blendMode(Blend.Normal)
     frame := Float(frameOf(self.clock + self.phase, 4, 8.0))
-    pureDrawSprite(m, tint, n.width, n.height, self.tex, frame * Rules.Cell, Rules.Cell, Rules.Cell, Rules.Cell)
+    pureDrawSprite(io, m, tint, n.width, n.height, self.tex, frame * Rules.Cell, Rules.Cell, Rules.Cell, Rules.Cell)
 # A mine drifting about, turning `spin` radians per second (0 once the game is over).
-record Mine(Actor, vx: Float, vy: Float, spin: Float, clock: Float, tex: Int) =
+record Mine(Actor, mut vx: Float, mut vy: Float, spin: Float, mut clock: Float, tex: Int) =
   fun create(sheet: Int, id: Int, at: Motion, spin: Float) -> Node =
     Mine.createAt(sheet, id, at, spin, 0.0)
@@ -225,41 +226,36 @@ record Mine(Actor, vx: Float, vy: Float, spin: Float, clock: Float, tex: Int) =
   fun createAt(sheet: Int, id: Int, at: Motion, spin: Float, clock: Float) -> Node =
     n := PureScene.custom(id, at.x - Rules.Half, at.y - Rules.Half, Rules.Size, Rules.Size,
       Mine(vx: at.vx, vy: at.vy, spin: spin, clock: clock, tex: sheet))
-    n.originX = Rules.Half
+    Node(..n, originX: Rules.Half, originY: Rules.Half)
-    n.originY = Rules.Half
-    n
-  override fun act(self, own n: Node, dt: Float) -> Node =
+  override fun act(self, n: Node, dt: Float) -> Node =
     m := driftOf(Motion(x: n.x + Rules.Half, y: n.y + Rules.Half, vx: self.vx, vy: self.vy), Rules.MineRadius, dt)
     self.clock = self.clock + dt
-    n.x = m.x - Rules.Half
-    n.y = m.y - Rules.Half
     self.vx = m.vx
     self.vy = m.vy
-    n.rotation = n.rotation + self.spin * dt
+    Node(..n, x: m.x - Rules.Half, y: m.y - Rules.Half, rotation: n.rotation + self.spin * dt)
-    n
-  override fun draw(self, n: Node, m: Affine, tint: Color) =
+  override fun draw(self, io: Io, n: Node, m: Affine, tint: Color) =
     frame := Float(frameOf(self.clock, 4, 4.0))
-    pureDrawSprite(m, tint, n.width, n.height, self.tex, frame * Rules.Cell, 2.0 * Rules.Cell, Rules.Cell, Rules.Cell)
+    pureDrawSprite(io, m, tint, n.width, n.height, self.tex, frame * Rules.Cell, 2.0 * Rules.Cell, Rules.Cell, Rules.Cell)
 # A background star that twinkles.
-record Star(Actor, seed: Float, clock: Float) =
+record Star(Actor, seed: Float, mut clock: Float) =
   fun create(i: Int) -> Node =
     r := 1.0 + Float(i % 3) * 0.5
     PureScene.custom(Id.Star + i, Float({i * 7919} % 800) - r, Float({i * 104729} % 600) - r, r * 2.0, r * 2.0,
       Star(seed: Float(i), clock: 0.0))
-  override fun act(self, own n: Node, dt: Float) -> Node =
+  override fun act(self, n: Node, dt: Float) -> Node =
     self.clock = self.clock + dt
     n
-  override fun draw(self, n: Node, m: Affine, tint: Color) =
+  override fun draw(self, io: Io, n: Node, m: Affine, tint: Color) =
     twinkle := 0.25 + 0.2 * Math.sin(self.clock * 2.0 + self.seed)
     r := n.width / 2.0
     c := m.apply(Vec2(x: r, y: r))
-    drawCircle(c.x, c.y, r * m.scaleX(), Color(r: 0.7, g: 0.8, b: 1.0, a: twinkle * tint.a))
+    io.drawCircle(c.x, c.y, r * m.scaleX(), Color(r: 0.7, g: 0.8, b: 1.0, a: twinkle * tint.a))
 # --- reading and changing the tree ---
@@ -279,12 +275,11 @@ fun find(root: Node, id: Int) -> Node =
 fun kidsOf(n: Node) -> Slice[Node] =
   PureScene.childrenOf(n) ?: crash "not a group"
-fun setVisible(own n: Node, v: Bool) -> Node =
+fun setVisible(n: Node, v: Bool) -> Node =
-  n.visible = v
+  Node(..n, visible: v)
-  n
 # The group `g` with `k` added as its last child.
-fun addKid(own g: Node, own k: Node) -> Node =
+fun addKid(g: Node, k: Node) -> Node =
   ks := kidsOf(g)
   ks.push(k)
   g
@@ -308,18 +303,33 @@ fun textOf(n: Node) -> Str =
 fun hudLabel(id: Int, text: Str, x: Float, y: Float, size: Float, c: Color) -> Node =
   l := PureScene.label(id, text, x, y, size)
-  l.color = c
+  Node(..l, color: c)
-  l
 fun icon(sheet: Int, i: Int) -> Node =
   s := PureScene.sprite(Id.Icon + i, sheet, Rules.ArenaW - 40.0 - Float(i) * 36.0, 12.0, 32.0, 32.0)
-  s.kind = Sprite(tex: sheet, srcX: 0.0, srcY: 0.0, srcW: Rules.Cell, srcH: Rules.Cell)
+  Node(..s, kind: Sprite(tex: sheet, srcX: 0.0, srcY: 0.0, srcW: Rules.Cell, srcH: Rules.Cell))
-  s
 # The whole scene: backdrop, stars, mines, orbs, ship and HUD layers, in drawing order.
 # The layer groups are 0 x 0 so they never swallow a click; the HUD holds the
 # game-over overlay with its restart button.
+# The starting spots of the orbs and mines, and the generator to continue from.
+record Spots(orbs: Slice[Motion], mines: Slice[Motion], rng: Random)
+fun startSpots(rng: Random, ship: ShipState) -> Spots =
+  orbs := Slice[Motion]()
+  mines := Slice[Motion]()
+  r := rng
+  for i := range Rules.OrbCount
+    sp := spawn(r, ship.x, ship.y, 120.0, 40.0)
+    r = sp.rng
+    orbs.push(sp.at)
+  for i := range mineCount(0)
+    sp := spawn(r, ship.x, ship.y, 220.0, 90.0)
+    r = sp.rng
+    mines.push(sp.at)
+  Spots(orbs: orbs, mines: mines, rng: r)
-fun buildRoot(rng: Random, sheet: Int, best: Int) -> Node =
+fun buildRoot(spots: Spots, sheet: Int, best: Int) -> Node =
   ship := newShip()
   stars := Slice[Node]()
   for i := range 40
@@ -327,19 +337,18 @@ fun buildRoot(rng: Random, sheet: Int, best: Int) -> Node =
   mines := Slice[Node]()
   orbs := Slice[Node]()
   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)))
+    orbs.push(Orb.create(sheet, Float(i) * 0.1, Id.Orb + i, spots.orbs.at(i)))
   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))
+    mines.push(Mine.create(sheet, Id.Mine + i, spots.mines.at(i), 2.0))
-  btn := PureScene.button(Id.Restart, "Again", sheet, sheet, 340.0, 342.0, 120.0, 44.0)
+  b0 := PureScene.button(Id.Restart, "Again", sheet, sheet, 340.0, 342.0, 120.0, 44.0)
-  btn.color = Color(r: 0.5, g: 0.8, b: 1.0, a: 0.9)
+  btn := Node(..b0, color: Color(r: 0.5, g: 0.8, b: 1.0, a: 0.9), visible: false)
-  btn.visible = false
   over := Slice(
     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)),
     hudLabel(Id.OverTitle, "Game over", 300.0, 244.0, 48.0, Color.Red),
     hudLabel(Id.OverHint, "Press Enter to play again", 270.0, 300.0, 24.0, Color.White),
     btn)
-  overlay := PureScene.group(Id.Overlay, 0.0, 0.0, 0.0, 0.0, over)
+  o0 := PureScene.group(Id.Overlay, 0.0, 0.0, 0.0, 0.0, over)
-  overlay.visible = false
+  overlay := Node(..o0, visible: false)
   hud := Slice(
     hudLabel(Id.Score, "Score 0", 16.0, 12.0, 28.0, Color.White),
     hudLabel(Id.Best, "Best {best}", 16.0, 44.0, 20.0, Color.Yellow))
@@ -360,32 +369,41 @@ fun buildRoot(rng: Random, sheet: Int, best: Int) -> Node =
 # The host-facing shell: the current pure `Stage` plus the run's state. It is the
 # only thing that is replaced from frame to frame.
 record World(
-  stage: Stage,
+  mut stage: Stage,
-  ship: ShipState,
+  mut ship: ShipState,
-  rng: Random,
+  mut rng: Random,
-  mines: Int,
+  mut mines: Int,
-  score: Int,
+  mut score: Int,
-  best: Int,
+  mut best: Int,
-  lives: Int,
+  mut lives: Int,
-  over: Bool,
+  mut over: Bool,
-  clock: Float,
+  mut clock: Float,
-  wasDown: Bool,
+  mut wasDown: Bool,
   sheet: Int,
-  pickupSound: Int,
+  mut pickupSound: Int,
-  hitSound: Int,
+  mut hitSound: Int,
-  overSound: Int,
+  mut overSound: Int,
-  musicSound: Int)
+  mut musicSound: Int)
 fun newWorld(seed: Int, sheet: Int) -> World =
+  ship := newShip()
-  rng := Random(seed: seed)
+  spots := startSpots(Random.seeded(seed), ship)
-  root := buildRoot(rng, sheet, 0)
+  next := spots.rng
   World(
-    stage: SceneInput.stage(root), ship: newShip(), rng: rng, mines: mineCount(0), score: 0, best: 0,
+    stage: SceneInput.stage(buildRoot(spots, sheet, 0)), ship: ship, rng: next, mines: mineCount(0), score: 0, best: 0,
     lives: Rules.StartLives, over: false, clock: 0.0, wasDown: false, sheet: sheet,
     pickupSound: -1, hitSound: -1, overSound: -1, musicSound: -1)
+fun modifyRoot(st: Stage, id: Int, f: fn(Node) -> Node) -> Stage =
+  match st
+    Stage(root, camera, captured) => Stage(root: SceneTree.modify(root, id, f), camera: camera, captured: captured)
+fun withCamera(st: Stage, camera: Affine) -> Stage =
+  match st
+    Stage(root, _, captured) => Stage(root: root, camera: camera, captured: captured)
 fun swap(w: World, id: Int, f: fn(Node) -> Node) =
-  w.stage.root = SceneTree.modify(w.stage.root, id, f)
+  w.stage = modifyRoot(w.stage, id, f)
 # Starts a fresh game, keeping the best score, the camera and the random stream.
 fun restart(w: World) =
@@ -395,7 +413,10 @@ fun restart(w: World) =
   w.over = false
   w.ship = newShip()
   w.mines = mineCount(0)
+  spots := startSpots(w.rng, w.ship)
+  next := spots.rng
+  w.rng = next
-  w.stage = Stage(root: buildRoot(w.rng, w.sheet, w.best), camera: w.stage.camera, captured: null)
+  w.stage = Stage(root: buildRoot(spots, w.sheet, w.best), camera: w.stage.camera, captured: null)
 # Copies the score, best score, lives and game-over panel into the HUD actors.
 fun syncHud(w: World) =
@@ -434,8 +455,7 @@ fun mineActor(sheet: Int, id: Int, at: Motion, spin: Float) -> Node =
 fun stillMine(sheet: Int, id: Int, a: Node) -> Node =
   m := Mine.createAt(sheet, id, Motion(x: cx(a), y: cy(a), vx: 0.0, vy: 0.0), 0.0, clockOf(a))
-  m.rotation = a.rotation
+  Node(..m, rotation: a.rotation)
-  m
 # Moves the ship node to the ship state; it blinks while it is hurt, and is hidden once the game is over.
 fun showShip(w: World) =
@@ -444,18 +464,14 @@ fun showShip(w: World) =
   s := w.ship
   swap(w, Id.Ship, |a| shipActor(a, s, visible))
-fun shipActor(own a: Node, s: ShipState, visible: Bool) -> Node =
+fun shipActor(a: Node, s: ShipState, visible: Bool) -> Node =
-  a.x = s.x - Rules.Half
-  a.y = s.y - Rules.Half
-  a.rotation = s.rotation
+  Node(..a, x: s.x - Rules.Half, y: s.y - Rules.Half, rotation: s.rotation, visible: visible)
-  a.visible = visible
-  a
 fun overlaps(ax: Float, ay: Float, ra: Float, bx: Float, by: Float, rb: Float) -> Bool =
   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: Slice[Input], events: Slice[UiEvent]) -> Stage =
+fun frameInto(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))
@@ -483,7 +499,9 @@ fun advance(w: World, ax: Float, ay: Float, dt: Float, inputs: Slice[Input]) ->
     if overlaps(ship.x, ship.y, Rules.ShipRadius, cx(orb), cy(orb), Rules.OrbRadius)
       w.score = w.score + Rules.OrbPoints
       changed = true
-      at := spawn(w.rng, ship.x, ship.y, 120.0, 40.0)
+      sp := spawn(w.rng, ship.x, ship.y, 120.0, 40.0)
+      w.rng = sp.rng
+      at := sp.at
       sheet := w.sheet
       id := Id.Orb + i
       phase := Float(i) * 0.1
@@ -491,7 +509,9 @@ fun advance(w: World, ax: Float, ay: Float, dt: Float, inputs: Slice[Input]) ->
   while w.mines < mineCount(w.score)
     sheet := w.sheet
     id := Id.Mine + w.mines
-    at := spawn(w.rng, ship.x, ship.y, 220.0, 90.0)
+    sp := spawn(w.rng, ship.x, ship.y, 220.0, 90.0)
+    w.rng = sp.rng
+    at := sp.at
     swap(w, Id.MineLayer, |g| addKid(g, Mine.create(sheet, id, at, 2.0)))
     w.mines = w.mines + 1
   for i := range w.mines
@@ -499,9 +519,7 @@ fun advance(w: World, ax: Float, ay: Float, dt: Float, inputs: Slice[Input]) ->
     if w.ship.hurt <= 0.0 && overlaps(ship.x, ship.y, Rules.ShipRadius, cx(mine), cy(mine), Rules.MineRadius)
       w.lives = w.lives - 1
       cur := w.ship
-      s := ShipState(..cur)
-      s.hurt = Rules.HurtTime
+      w.ship = ShipState(..cur, hurt: Rules.HurtTime)
-      w.ship = s
       changed = true
       if w.lives <= 0
         w.over = true
@@ -523,7 +541,7 @@ fun fitCamera(sw: Float, sh: Float) -> Affine =
   Affine(a: zoom, b: 0.0, c: 0.0, d: zoom, e: {sw - zoom * Rules.ArenaW} / 2.0, f: {sh - zoom * Rules.ArenaH} / 2.0)
 fun fit(w: World, sw: Float, sh: Float) =
-  w.stage.camera = fitCamera(sw, sh)
+  w.stage = withCamera(w.stage, fitCamera(sw, sh))
 # --- host glue: input, sound, drawing ---
@@ -531,17 +549,17 @@ fun musicVolume() -> Float =
   0.3
 # Restarts the music loop from the top.
-fun startMusic(w: World) =
+fun startMusic(io: Io, w: World) =
-  soundStop(w.musicSound)
+  io.soundStop(w.musicSound)
-  soundLoop(w.musicSound, musicVolume())
+  io.soundLoop(w.musicSound, musicVolume())
-export fun init() -> World =
+export fun init(io: Io) -> World =
-  w := newWorld(2024, textureLoad("sprites.png"))
+  w := newWorld(io.randomSeed(), io.textureLoad("sprites.png"))
-  w.pickupSound = soundLoad("pickup.wav")
+  w.pickupSound = io.soundLoad("pickup.wav")
-  w.hitSound = soundLoad("hit.wav")
+  w.hitSound = io.soundLoad("hit.wav")
-  w.overSound = soundLoad("gameover.wav")
+  w.overSound = io.soundLoad("gameover.wav")
-  w.musicSound = soundLoad("music.wav")
+  w.musicSound = io.soundLoad("music.wav")
-  startMusic(w)
+  startMusic(io, w)
   w
 fun axis(negative: Bool, positive: Bool) -> Float =
@@ -552,35 +570,35 @@ fun axis(negative: Bool, positive: Bool) -> Float =
   else
     0.0
-export fun update(w: World, dt: Float) =
+export fun update(io: Io, w: World, dt: Float) =
-  if w.over && {isKeyPressed(Key.Enter) || isKeyPressed(Key.KeyR)}
+  if w.over && {io.isKeyPressed(Key.Enter) || io.isKeyPressed(Key.KeyR)}
     restart(w)
-    startMusic(w)
+    startMusic(io, w)
-  inputs := SceneInput.pollPointer(w.wasDown)
+  inputs := SceneInput.pollPointer(io, w.wasDown)
-  w.wasDown = isMouseDown(0)
+  w.wasDown = io.isMouseDown(0)
-  left := isKeyDown(Key.Left) || isKeyDown(Key.KeyA)
+  left := io.isKeyDown(Key.Left) || io.isKeyDown(Key.KeyA)
-  right := isKeyDown(Key.Right) || isKeyDown(Key.KeyD)
+  right := io.isKeyDown(Key.Right) || io.isKeyDown(Key.KeyD)
-  up := isKeyDown(Key.Up) || isKeyDown(Key.KeyW)
+  up := io.isKeyDown(Key.Up) || io.isKeyDown(Key.KeyW)
-  down := isKeyDown(Key.Down) || isKeyDown(Key.KeyS)
+  down := io.isKeyDown(Key.Down) || io.isKeyDown(Key.KeyS)
   score := w.score
   lives := w.lives
   restarted := advance(w, axis(left, right), axis(up, down), dt, inputs)
   if restarted
-    startMusic(w)
+    startMusic(io, w)
     return
   if w.score > score
-    soundPlay(w.pickupSound, 0.8)
+    io.soundPlay(w.pickupSound, 0.8)
   if w.lives < lives
     if w.over
-      soundStop(w.musicSound)
+      io.soundStop(w.musicSound)
-      soundPlay(w.overSound, 1.0)
+      io.soundPlay(w.overSound, 1.0)
     else
-      soundPlay(w.hitSound, 1.0)
+      io.soundPlay(w.hitSound, 1.0)
-export fun draw(w: World) =
+export fun draw(io: Io, w: World) =
-  fit(w, screenWidth(), screenHeight())
+  fit(w, io.screenWidth(), io.screenHeight())
-  clear(Color.rgb(0.04, 0.05, 0.1))
+  io.clear(Color.rgb(0.04, 0.05, 0.1))
-  w.stage.draw()
+  w.stage.draw(io)
 # --- tests ---

plum-examples/{tools → games/tools}/make_sounds.py RENAMED Viewed

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """Generates the Orb Run sound effects and music loop into ../assets.
-Standard library only: python3 plum-examples/tools/make_sounds.py
+Standard library only: python3 plum-examples/games/tools/make_sounds.py
 Everything is synthesized here, so the WAVs are original and reproducible.
 All files are mono, 16-bit, 22050 Hz.
 """

plum-examples/{tools → games/tools}/make_sprites.py RENAMED Viewed

File without changes

plum-examples/io.plum DELETED Viewed

@@ -1,14 +0,0 @@
-import std/Str
-# `printLn` mirrors `libs/std/os.plum`'s declaration; redeclared locally
-# (rather than `import std/os`) so this stays the SMALLEST possible example
-# — `import std/os` pulls in every other filesystem extern os.plum declares
-# too, which the Rust-level `ioExampleCompilesAndRunsCorrectly` test (which
-# actually RUNS this module under wasmtime, providing real host imports)
-# would then all need stubs for.
-extern fun printLn(s: Str)
-fun main() =
-  printLn("hello from plum")
-  name := "world"
-  printLn("hello, {name}!")

plum-examples/loops.plum DELETED Viewed

@@ -1,125 +0,0 @@
-# Loops: `while` condition loops, `for ... := range` iteration over ranges and
-# collections, with inline filtering and mapping.
-import std/Str
-import std/Int
-import std/Float
-import std/Slice
-import std/Array
-import std/Testing
-import std/Seq
-fun sumList(xs: Slice[Int]) -> Int =
-  total := 0
-  for x := range xs
-    total = total + x
-  return total
-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 := Slice(1, 2, 3, 4)
-  assert sumList(xs) == 10
-  arr := Array.filled(3, 7)
-  total := 0
-  for a := range arr
-    total = total + a
-  assert total == 21
-test "index_value_binders: i, x"
-  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 := 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 := 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 := Slice(1, 2, 3, 4, 5)
-  total := 0
-  for x := range xs
-    if x == 2
-      continue
-    if x == 5
-      break
-    total = total + x
-  assert total == 8
-  assert firstOver(xs, 3) == 4
-  assert firstOver(xs, 9) == -1
-test "nested iterable loops"
-  xs := Slice(1, 2)
-  ys := Slice(10, 20)
-  total := 0
-  for x := range xs
-    for y := range ys
-      total = total + x * y
-  assert total == 90
-test "range_int: 0 to n-1, empty for 0, continue still advances"
-  total := 0
-  for i := range 5
-    total = total + i
-  assert total == 10
-  n := 0
-  for _ := range 0
-    n = n + 1
-  assert n == 0
-  odd := 0
-  for i := range 6
-    if i % 2 == 0
-      continue
-    odd = odd + i
-  assert odd == 9
-test "range_until_to_downTo: bounds incl. empty ranges"
-  a := 0
-  for i := range 2.until(6)
-    a = a + i
-  assert a == 14
-  b := 0
-  for i := range 1.to(4)
-    b = b + i
-  assert b == 10
-  c := 0
-  for i := range 4.downTo(1)
-    c = c * 10 + i
-  assert c == 4321
-  n := 0
-  for _ := range 5.until(5)
-    n = n + 1
-  for _ := range 1.downTo(2)
-    n = n + 1
-  for _ := range 3.to(2)
-    n = n + 1
-  assert n == 0
-test "range_stepBy: stepBy on until and to"
-  total := 0
-  for i := range 0.until(10).stepBy(3)
-    total = total + i
-  assert total == 18
-  for i := range 1.to(10).stepBy(4)
-    total = total + i
-  assert total == 18 + 15
-test "range_seq_terminal: a terminal over an Int range"
-  evens := for i := range 0.until(10).filter()
-    i % 2 == 0
-  assert evens.length() == 5

plum-examples/numbers.plum CHANGED Viewed

@@ -1,7 +1,91 @@
+# Numbers: Int and Float methods, operators on numbers and constants.
 import std/Str
 import std/Int
 import std/Float
 import std/Math
+import std/Slice
+# ==== operators ====
+# Operators on non-primitive operands call methods: `a + b` is `a.add(b)`,
+# `-a` is `a.neg()`, `a == b` is `a.eq(b)`, `a < b` is `a.lt(b)`.
+record Vec2(x: Float, y: Float) =
+  fun toStr(self) -> Str =
+    "Vec2({self.x}, {self.y})"
+  fun add(self, o: Vec2) -> Vec2 =
+    Vec2(x: self.x + o.x, y: self.y + o.y)
+  fun mul(self, s: Float) -> Vec2 =
+    Vec2(x: self.x * s, y: self.y * s)
+  fun neg(self) -> Vec2 =
+    Vec2(x: 0.0 - self.x, y: 0.0 - self.y)
+  fun eq(self, o: Vec2) -> Bool =
+    self.x == o.x && self.y == o.y
+  fun lt(self, o: Vec2) -> Bool =
+    self.x < o.x
+  fun le(self, o: Vec2) -> Bool =
+    self.x <= o.x
+record Plain(v: Int)
+fun double(a: T) -> T =
+  a + a
+# ==== constants ====
+# Constants and static functions live inside a type's body or a `primitive`
+# namespace — there are no top-level constants. `Name = expr` declares an
+# associated constant, a `fun` without `self` a static function. They are
+# reached as `Type.Name` / `Type.f()` from anywhere, including inside the same
+# body. Constant names are unique per type, not global.
+# A `primitive` whose name is not a built-in type is a stateless namespace.
+primitive Grid =
+  Width = 8
+  Height = Grid.Width * 2
+  CellScale = 2.5
+  Name = "plum"
+  DebugDraw = true
+  fun cells() -> Int =
+    Grid.Width * Grid.Height
+record Tile(x: Int) =
+  Width = 100
+  fun offset(self) -> Int = Tile.Width + self.x
+  fun origin() -> Tile =
+    Tile(x: 0)
+record Wrap[T](v: T) =
+  fun area(self) -> Int = Grid.Width * Grid.Height
+struct ConstVec2(x: Float, y: Float) =
+  Zero = ConstVec2(x: 0.0, y: 0.0)
+fun scaled(n: Float) -> Float = n * Grid.CellScale
+primitive Shelf =
+  Sides = 4
+  Names = Slice("a", "b", "c")
+  fun sidesTwice() -> Int =
+    twice(Shelf.Sides)
+  fun twice(n: Int) -> Int =
+    n * 2
+# ==== numbers tests ====
 # Regression coverage for the `primitive Int` / `primitive Float` methods
 # (`plum-std/Int.plum`, `plum-std/Float.plum`), the `Math` namespace and the
@@ -106,3 +190,61 @@ test "associated constants live on their type"
   assert Float.Tau == 2.0f * Float.Pi
   assert Float.HalfPi * 2.0f == Float.Pi
   assert Float.Max > 1.0e300
+# ==== operators tests ====
+test "vec2_add_operator"
+  r := Vec2(x: 1.0, y: 2.0) + Vec2(x: 3.0, y: 4.0)
+  assert r.x == 4.0
+  assert r.y == 6.0
+test "mul_scalar_rhs"
+  r := Vec2(x: 1.0, y: 2.0) * 2.0
+  assert r.x == 2.0
+  assert r.y == 4.0
+test "neg"
+  r := -Vec2(x: 1.0, y: -2.0)
+  assert r.x == -1.0
+  assert r.y == 2.0
+test "eq_and_neq"
+  a := Vec2(x: 1.0, y: 2.0)
+  assert a == Vec2(x: 1.0, y: 2.0)
+  assert a != Vec2(x: 1.0, y: 3.0)
+  assert !{a == Vec2(x: 0.0, y: 0.0)}
+test "lt_ordering"
+  a := Vec2(x: 1.0, y: 0.0)
+  b := Vec2(x: 2.0, y: 0.0)
+  assert a < b
+  assert !{b < a}
+  assert a <= b
+test "operators work through a generic"
+  d := double(Vec2(x: 1.0, y: 1.0))
+  assert d.x == 2.0
+  assert double(4) == 8
+# ==== constants tests ====
+test "consts are usable in fns, methods, generics and derived consts"
+  assert Grid.Height == 16
+  assert Grid.cells() == 128
+  assert Tile(x: 1).offset() == 101
+  assert Wrap(v: 3.5).area() == 128
+  assert scaled(2.0) == 5.0
+  assert Grid.Name == "plum"
+  assert Grid.DebugDraw
+test "the same const name can live on two types"
+  assert Grid.Width == 8
+  assert Tile.Width == 100
+test "a struct can hold a constant instance of itself"
+  assert ConstVec2.Zero.x == 0.0
+  assert Tile.origin().x == 0
+test "a primitive holds a list constant and a static fn reading a sibling const"
+  assert Shelf.Names.length() == 3
+  assert Shelf.sidesTwice() == 8

plum-examples/operators.plum DELETED Viewed

@@ -1,67 +0,0 @@
-module operators
-import std/Str
-import std/Int
-import std/Float
-# Operators on non-primitive operands call methods: `a + b` is `a.add(b)`,
-# `-a` is `a.neg()`, `a == b` is `a.eq(b)`, `a < b` is `a.lt(b)`.
-record Vec2(x: Float, y: Float) =
-  fun toStr(self) -> Str =
-    "Vec2({self.x}, {self.y})"
-  fun add(self, o: Vec2) -> Vec2 =
-    Vec2(x: self.x + o.x, y: self.y + o.y)
-  fun mul(self, s: Float) -> Vec2 =
-    Vec2(x: self.x * s, y: self.y * s)
-  fun neg(self) -> Vec2 =
-    Vec2(x: 0.0 - self.x, y: 0.0 - self.y)
-  fun eq(self, o: Vec2) -> Bool =
-    self.x == o.x && self.y == o.y
-  fun lt(self, o: Vec2) -> Bool =
-    self.x < o.x
-  fun le(self, o: Vec2) -> Bool =
-    self.x <= o.x
-record Plain(v: Int)
-fun double(a: T) -> T =
-  a + a
-test "vec2_add_operator"
-  r := Vec2(x: 1.0, y: 2.0) + Vec2(x: 3.0, y: 4.0)
-  assert r.x == 4.0
-  assert r.y == 6.0
-test "mul_scalar_rhs"
-  r := Vec2(x: 1.0, y: 2.0) * 2.0
-  assert r.x == 2.0
-  assert r.y == 4.0
-test "neg"
-  r := -Vec2(x: 1.0, y: -2.0)
-  assert r.x == -1.0
-  assert r.y == 2.0
-test "eq_and_neq"
-  a := Vec2(x: 1.0, y: 2.0)
-  assert a == Vec2(x: 1.0, y: 2.0)
-  assert a != Vec2(x: 1.0, y: 3.0)
-  assert !{a == Vec2(x: 0.0, y: 0.0)}
-test "lt_ordering"
-  a := Vec2(x: 1.0, y: 0.0)
-  b := Vec2(x: 2.0, y: 0.0)
-  assert a < b
-  assert !{b < a}
-  assert a <= b
-test "operators work through a generic"
-  d := double(Vec2(x: 1.0, y: 1.0))
-  assert d.x == 2.0
-  assert double(4) == 8

plum-examples/optionals.plum DELETED Viewed

@@ -1,232 +0,0 @@
-import std/Int
-import std/Str
-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`,
-# `while x := opt`, `opt!` (crashes on null) and `opt == null`; `catch` and `try`
-# are for errors only. `!T?` is an error union whose success value is an optional.
-#
-# `obj?.field` / `obj?.method(args)` is safe navigation: it reaches into an
-# optional without unwrapping it and passes null through. A field that is itself
-# a `T?` flattens, so `u?.target?.name` is one `Str?`. It is sugar for
-# `obj.andThen(|v| v.field)`.
-record Box(label: Str)
-record Holder(item: Box?, count: Int?)
-fun maybeBox(c: Bool) -> Box? =
-  if c
-    return Box(label: "in")
-  return null
-fun maybeInt(c: Bool) -> Int? =
-  if c
-    return 7
-  null
-fun orFive(n: Int? = null) -> Int =
-  n ?: 5
-fun failOnNull(c: Bool) -> error{Absent}!Int =
-  n := maybeInt(c) ?: return error.Absent
-  n + 1
-fun nullOnNull(c: Bool) -> Int? =
-  n := maybeInt(c) ?: return null
-  n * 2
-fun chainDefault(a: Int?, b: Int?) -> Int =
-  a ?: b ?: 99
-fun fallible(n: Int) -> error{Bad}!Int? =
-  if n < 0
-    return error.Bad
-  if n == 0
-    return null
-  n
-fun viaTry(n: Int) -> error{Bad}!Int =
-  v := try fallible(n)
-  v ?: -1
-fun nextItem(items: Slice[Int], i: Int) -> Int? =
-  if i < items.length()
-    return items.get(i)!
-  null
-fun sparse() -> Slice[Int?] =
-  Slice(1, null, 3)
-fun sumBig() -> Int =
-  Int.Max + Int.Min
-record Person(name: Str, age: Int) =
-  fun birthday(self) -> Int =
-    self.age + 1
-record Target(name: Str)
-record User(name: Str, target: Target?)
-fun personName(p: Person?) -> Str? =
-  p?.name
-fun personBirthday(p: Person?) -> Int? =
-  p?.birthday()
-fun somePerson() -> Person? =
-  Person(name: "Ann", age: 3)
-fun noPerson() -> Person? =
-  return null
-fun noTarget() -> Target? =
-  return null
-fun maybeCount(n: Int? = null) -> Int? =
-  n
-fun noUser() -> User? =
-  return null
-fun targetName(u: User?) -> Str? =
-  u?.target?.name
-test "null_return_absent"
-  assert maybeBox(false) == null
-  assert maybeBox(true) != null
-  assert maybeInt(false) == null
-  assert null != maybeInt(true)
-test "null_field_and_arg"
-  h := Holder(item: null, count: null)
-  assert h.item == null
-  assert h.count == null
-  h2 := Holder(item: Box(label: "x"), count: 3)
-  assert h2.count! == 3
-  assert orFive(null) == 5
-  assert orFive(8) == 8
-  xs := sparse()
-  assert xs.length() == 3
-test "elvis_default"
-  assert {maybeInt(false) ?: 4} == 4
-  assert {maybeInt(true) ?: 4} == 7
-  assert {maybeBox(false)?.label ?: "none"} == "none"
-  assert {maybeBox(true)?.label ?: "none"} == "in"
-test "elvis_return_error"
-  assert {failOnNull(true) catch 0} == 8
-  assert {failOnNull(false) catch 0} == 0
-test "elvis_return_null"
-  assert nullOnNull(true)! == 14
-  assert nullOnNull(false) == null
-test "elvis_chain_right_assoc"
-  assert chainDefault(null, null) == 99
-  assert chainDefault(null, 2) == 2
-  assert chainDefault(1, 2) == 1
-test "if_bind_optional"
-  r := 0
-  if x := maybeInt(true)
-    r = x
-  else
-    r = -1
-  assert r == 7
-  if y := maybeInt(false)
-    r = y
-  else
-    r = -1
-  assert r == -1
-  assert {if v := maybeInt(true) then v + 1 else 0} == 8
-  assert {if w := maybeInt(false) then w + 1 else 0} == 0
-  if b := maybeBox(true)
-    assert b.label == "in"
-test "while_bind_optional"
-  items := Slice(3, 2, 1)
-  total := 0
-  i := 0
-  while v := nextItem(items, i)
-    total = total + v
-    i = i + 1
-  assert total == 6
-test "safe_nav_optional_flattens"
-  assert maybeBox(true)?.label! == "in"
-  assert maybeBox(false)?.label == null
-test "null_eq_ref and null_eq_int"
-  b := maybeBox(false)
-  assert b == null
-  n := maybeInt(true)
-  assert n != null
-  assert !{n == null}
-test "error_union_of_optional"
-  assert {viaTry(5) catch 0} == 5
-  assert {viaTry(0) catch 0} == -1
-  assert {viaTry(-3) catch 100} == 100
-  x := fallible(0)!
-  assert x == null
-  y := fallible(4)!
-  assert y! == 4
-test "int_min_literal"
-  assert Int.Min == -0x8000_0000_0000_0000
-  assert sumBig() == -1
-test "reassigning an optional local or field to null or a value"
-  o := maybeInt(true)
-  o = null
-  assert o == null
-  o = 4
-  assert o! == 4
-  b := maybeBox(true)
-  b = null
-  assert b == null
-  h := Holder(item: Box(label: "x"), count: 2)
-  h.count = null
-  h.item = null
-  assert h.count == null
-  assert h.item == null
-  h.count = 5
-  h.item = Box(label: "y")
-  assert h.count! == 5
-  assert h.item!.label == "y"
-test "safe navigation maps a field access over a present value, passes absence through"
-  assert personName(somePerson())! == "Ann"
-  assert {personName(noPerson()) ?: "gone"} == "gone"
-test "safe navigation maps a method call over a present value"
-  assert personBirthday(somePerson())! == 4
-  assert {personBirthday(noPerson()) ?: -1} == -1
-test "safe navigation chains through a nullable field"
-  full := User(name: "u", target: Target(name: "home"))
-  assert {targetName(full) ?: "none"} == "home"
-  assert {targetName(User(name: "v", target: noTarget())) ?: "none"} == "none"
-  assert {targetName(noUser()) ?: "none"} == "none"
-test "?: handles a nullable with a diverging or computed default"
-  p := somePerson() ?: crash "missing"
-  assert p.age == 3
-  q := noPerson() ?: Person(name: "gone", age: 1)
-  assert q.name == "gone"
-test "null is the absent value in an argument, a list element and a default"
-  u := User(name: "w", target: null)
-  assert {targetName(u) ?: "none"} == "none"
-  xs := sparse()
-  second := xs.get(1)!
-  assert {second ?: 9} == 9
-  first := xs.get(0)!
-  assert first! == 1
-  assert {maybeCount() ?: 5} == 5
-  assert maybeCount(7)! == 7

plum-examples/own_list.plum DELETED Viewed

@@ -1,33 +0,0 @@
-import std/Int
-import std/Float
-import std/Slice
-own record Cell(x: Float)
-test "map_in_place_updates_all"
-  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
-  assert {ys.at(1).x - 3.0}.abs() < 1e-6
-  assert {ys.at(2).x - 4.0}.abs() < 1e-6
-test "take_then_put_round_trip"
-  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)
-  assert xs.length() == 2
-  assert {xs.at(1).x - 12.0}.abs() < 1e-6
-  assert {xs.at(0).x - 1.0}.abs() < 1e-6
-test "at_borrows"
-  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 := 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/recursion.plum ADDED Viewed

@@ -0,0 +1,221 @@
+# Recursion: tail calls, the cons list and in-place slice updates.
+import std/Int
+import std/Float
+import std/List
+import std/Str
+import std/Slice
+import std/Array
+# ==== tail calls ====
+# Tail calls: deep recursion that must not overflow the stack.
+#
+# Self tail calls compile to loops, other tail calls use `return_call`, and a
+# constructor wrapped self call (`Cons(head: f(h), tail: map(t, f))`) is rewritten
+# to a loop (tail recursion modulo cons). All deep tests use 1,000,000 steps.
+fun sumTo(n: Int, acc: Int) -> Int =
+  if n == 0 then acc else sumTo(n - 1, acc + n)
+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) -> List[Int] =
+  if a >= b then Nil else Cons(head: a, tail: fromTo(a + 1, b))
+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: 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: List[T], acc: Int) -> Int = match xs
+  Nil => acc
+  Cons(_, t) => length(t, acc + 1)
+fun isEven(n: Int) -> Bool =
+  if n == 0 then true else isOdd(n - 1)
+fun isOdd(n: Int) -> Bool =
+  if n == 0 then false else isEven(n - 1)
+# `call` tail calls a closure value; `dec` tail calls `call`.
+fun call(f: fn(Int) -> Int, n: Int) -> Int = f(n)
+fun dec(n: Int) -> Int =
+  if n == 0 then 0 else call(dec, n - 1)
+record Counter(n: Int, total: Int)
+fun spin(c: Counter) -> Counter =
+  if c.n == 0 then c else spin(Counter(..c, n: c.n - 1, total: c.total + 2))
+fun depth(n: Int) -> Int =
+  if n == 0 then 0 else 1 + depth(n - 1)
+fun down(n: Int) -> error{Neg}!Int =
+  if n < 0
+    return error.Neg
+  if n == 0
+    return 5
+  down(n - 1)
+# ==== cons list ====
+# The std cons List: constant stack at 1,000,000 elements.
+fun range(a: Int, b: Int) -> List[Int] =
+  if a >= b then Nil else Cons(head: a, tail: range(a + 1, b))
+# ==== own list ====
+record Cell(x: Float)
+# ==== tail calls tests ====
+test "tail_sum_million"
+  assert sumTo(1000000, 0) == 500000500000
+test "tail_build_million"
+  assert length(build(1000000, Nil), 0) == 1000000
+test "fold_million"
+  xs := fromTo(0, 1000000)
+  assert foldl(xs, 0, |a, x| a + x) == 499999500000
+test "mutual_even_odd_million"
+  assert isEven(1000000)
+  assert !isOdd(1000000)
+  assert isOdd(999999)
+test "trmc_map_million"
+  ys := map(fromTo(0, 1000000), |x| x + 1)
+  assert length(ys, 0) == 1000000
+  assert foldl(ys, 0, |a, x| a + x) == 500000500000
+test "trmc_fromTo_million"
+  xs := fromTo(0, 1000000)
+  assert length(xs, 0) == 1000000
+test "closure_tail_million"
+  assert dec(1000000) == 0
+test "own_record_loop_100k"
+  c := spin(Counter(n: 100000, total: 0))
+  assert c.n == 0
+  assert c.total == 200000
+test "recursive_closure_million"
+  go := |n, acc| if n == 0 then acc else go(n - 1, acc + n)
+  assert go(1000000, 0) == 500000500000
+test "closure_body_tail_million"
+  fin := |n: Int| sumTo(n, 0)
+  assert fin(1000000) == 500000500000
+test "error_union_loop_million"
+  assert { down(1000000) catch 99 } == 5
+test "map_single_pass_million"
+  ys := map(fromTo(0, 1000000), |x| x * 2)
+  assert foldl(ys, 0, |a, x| a + x) == 999999000000
+# Non-tail recursion still uses the wasm stack. Measured limit under the 4 MiB
+# host stack: about 265,000 frames (260,000 passes, 270,000 traps) of `1 + depth(n - 1)`; tested well below it.
+test "tree_recursion_depth_recorded"
+  assert depth(100000) == 100000
+# ==== cons list tests ====
+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 "cons_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]"
+# ==== own list tests ====
+test "map_in_place_updates_all"
+  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
+  assert {ys.at(1).x - 3.0}.abs() < 1e-6
+  assert {ys.at(2).x - 4.0}.abs() < 1e-6
+test "take_then_put_round_trip"
+  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)
+  assert xs.length() == 2
+  assert {xs.at(1).x - 12.0}.abs() < 1e-6
+  assert {xs.at(0).x - 1.0}.abs() < 1e-6
+test "at_borrows"
+  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 := 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/{seq.plum → sequences.plum} RENAMED Viewed

@@ -1,11 +1,16 @@
-# Sequence adapters, terminals and chains: using `std/Seq` methods (`take`,
+# Sequences: Seq adapters and terminals, and user-defined fun* forms.
-# `skip`, `map`, `filter`, `find`, `fold`) to process collections in `for` loops.
 import std/Int
 import std/Float
 import std/Slice
 import std/Seq
 import std/Map
 import std/Str
+import std/Testing
+# ==== seq ====
+# Sequence adapters, terminals and chains: using `std/Seq` methods (`take`,
+# `skip`, `map`, `filter`, `find`, `fold`) to process collections in `for` loops.
 # Seq methods (`extend Seq[T]` in plum-std/Seq.plum): `xs.filter()` & co. in a
 # `for` source. Adapters (take, skip, stepBy, zip, reversed, chunks) reshape the
@@ -47,6 +52,78 @@ fun army() -> Slice[Soldier] =
     Soldier(name: "f", team: 2, hp: 8.0, x: 1.0, y: 0.0),
   )
+# ==== forms ====
+# User-defined `fun*` forms with `yield`: sources, folds and methods written in
+# plum and expanded at the call site (the built-in forms are in seq.plum).
+# for-forms: `for binders := range form(args), clauses` + body. A form is a `fun*`
+# with a yield type (`*T`); each `yield` runs the `for` body, and the whole
+# thing is expanded at the call site, so there are no closures. See
+# plum-std/Seq.plum and plum-core/src/forms.rs.
+record Fighter(name: Str, hp: Int, dead: Bool)
+fun sampleFighters() -> Slice[Fighter] =
+  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: Slice[T]) *T -> Int =
+  total := 0
+  for x := range xs
+    v := yield x
+    total = total + v
+  total
+# a user form with two binders and a statement body: the 8 neighbours of (x, y)
+fun* neighbours(x: Int, y: Int) *(Int, Int) =
+  for dx := range 3
+    for dy := range 3
+      if dx != 1 || dy != 1
+        yield x + dx - 1, y + dy - 1
+# a user form built from another form: `yield` sits inside `each`'s body
+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: Slice[Int]) -> Int =
+  for x := range xs.each()
+    if x > 10
+      return x
+  return -1
+fun returnedForm(xs: Slice[Int]) -> Slice[Int] =
+  return for x := range xs.map()
+    x + 1
+fun tailForm(xs: Slice[Int]) -> Int =
+  for x := range sumBy(xs)
+    x * 2
+# A type with a fun* method: `self` is bound to the receiver at the use site.
+record Countdown(from: Int) =
+  fun* ticks(self) *Int =
+    i := self.from
+    while i > 0
+      cur := i
+      i = i - 1
+      yield cur
+  # `for a, b := range countdown`: two binders pick `entries`.
+  fun* entries(self) *(Int, Int) =
+    i := self.from
+    while i > 0
+      cur := i
+      i = i - 1
+      yield cur, cur * cur
+# ==== seq tests ====
 test "seq_method_filter: a List has no filter of its own, so Seq.filter is used"
   xs := Slice(1, 2, 3, 4, 5, 6)
   evens := for x := range xs.filter()
@@ -234,3 +311,85 @@ test "materializing stages are separate statements"
   hps := for u := range alive.map(), if u.team == 1
     u.hp
   assert hps.length() == 3
+# ==== forms tests ====
+test "user_form_sumBy"
+  fighters := sampleFighters()
+  hp := for u := range sumBy(fighters)
+    u.hp
+  assert hp == 17
+  odd := for x := range sumBy(Slice(1, 2, 3, 4, 5)), if x % 2 == 1
+    x
+  assert odd == 9
+test "user_form_neighbours_grid: two binders, statement body"
+  count := 0
+  sum := 0
+  for nx, ny := range neighbours(5, 5), if nx > 5
+    count = count + 1
+    sum = sum + ny
+  assert count == 3
+  assert sum == 15
+test "break_continue_return_semantics"
+  xs := Slice(1, 2, 3, 4, 5)
+  total := 0
+  for x := range xs.each()
+    if x == 2
+      continue
+    if x == 5
+      break
+    total = total + x
+  assert total == 8
+  assert firstBig(Slice(1, 20, 30)) == 20
+  assert firstBig(xs) == -1
+  prefix := for x := range xs.filter()
+    if x == 4
+      break
+    x > 1
+  assert prefix.length() == 2
+test "composed form: a form that uses another form"
+  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 := Slice(1, 2)
+  ys := Slice(10, 20)
+  total := for a := range sumBy(xs)
+    inner := for b := range sumBy(ys)
+      a * b
+    inner
+  assert total == 90
+test "return for-form: the form's value is returned"
+  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(Slice(1, 2, 3)) == 12
+test "fun_star_method_uses_self"
+  c := Countdown(from: 4)
+  seen := 0
+  for t := range c.ticks()
+    seen = seen * 10 + t
+  assert seen == 4321
+  evens := for t := range c.ticks().map(), if t % 2 == 0
+    t * 100
+  assert evens.length() == 2
+  assert evens.at(0) == 400
+test "two_binder_uses_entries_method: a custom type's entries()"
+  c := Countdown(from: 3)
+  total := 0
+  for n, sq := range c
+    total = total + n * 1000 + sq
+  assert total == 3 * 1000 + 9 + 2 * 1000 + 4 + 1000 + 1
+  for _, sq := range c
+    total = total + sq
+  assert total == 6014 + 14

plum-examples/struct_union_members.plum CHANGED Viewed

@@ -16,7 +16,7 @@ struct Wait(left: Float)
 record Chain(steps: Slice[Step])
-trait Thing(x: Float, tag: Int) =
+trait Thing(mut x: Float, tag: Int) =
   fun clone(self) -> Thing
 record Box(Thing(x, tag), size: Float) =

plum-examples/structs_records.plum CHANGED Viewed

@@ -1,12 +1,16 @@
-# Structs and records: `struct` is a small copy-semantics value type (flattened
+# Structs and records, digit names and annotated locals.
-# into wasm locals, no heap allocation); `record` is a reference type shared on
-# assignment. Both have named fields, methods, constants, positional or named
-# construction, field mutation and spread update (`Point(..p, x: 1)`).
-module structs_records
 import std/Str
 import std/Int
 import std/Float
 import std/Map
+import std/Slice
+# ==== structs records ====
+# Structs and records: `struct` is a small copy-semantics value type (flattened
+# into wasm locals, no heap allocation); `record` is a reference type shared on
+# assignment. Both have named fields, methods, constants, positional or named
+# construction, field mutation and spread update (`Point(..p, x: 1)`).
 # ---- struct: value semantics ----
@@ -36,7 +40,7 @@ struct Color(r: Int, g: Int, b: Int, a: Int)
 struct Cell(pos: Vec2, solid: Bool, tint: Color)
-record Player(pos: Vec2, hp: Int)
+record Player(mut pos: Vec2, hp: Int)
 fun applyTo(v: Vec2, cb: fn(Vec2) -> Vec2) -> Vec2 =
   cb(v)
@@ -81,7 +85,7 @@ fun bump(v: Vec2) -> Float =
 # ---- record: reference semantics ----
-record Point(x: Int, y: Int)
+record Point(mut x: Int, y: Int)
 # A method takes `self` first; a `fun` without `self` is a static (`Vec2.zero()`).
 record Cat(name: Str, age: Int) =
@@ -123,10 +127,9 @@ record Bag(n: Int) =
 # ---- embedding records and override ----
-record Counter(start: Int) =
+record Counter(mut count: Int) =
   fun init(self) =
-    self.count: Int = self.start
     self.log: Str = ""
   fun bump(self) =
@@ -135,7 +138,7 @@ record Counter(start: Int) =
   fun show(self) -> Str =
     "counter {self.count}"
-record Scoreboard(Counter(start), name: Str) =
+record Scoreboard(Counter(count), name: Str) =
   fun init(self) =
     self.best: Int = 0
@@ -143,6 +146,76 @@ record Scoreboard(Counter(start), name: Str) =
   override fun show(self) -> Str =
     "{self.name}: {self.Counter.show()}"
+# ==== digit names ====
+# Type and variant names may contain digits (`V2`, `A1`, `E1`). They are
+# resolved by position: where a type or variant name is expected it is one;
+# `Type.Name` consts such as `V2.K1` and `Int.Max` keep working.
+enum V2 =
+  | A1
+  | B2
+  K1 = 40
+record A1(n: Int)
+error S1 = E1 | E2
+fun fail(n: Int) -> S1!Int =
+  if n == 1
+    return error.E1
+  if n == 2
+    return error.E2
+  n
+fun asInt(w: V2) -> Int =
+  match w
+    A1(n) => n
+    B2 => 0
+fun payload(w: V2) -> Int =
+  if A1(n) := w
+    return n
+  0
+fun isB2(w: V2) -> Int =
+  if B2 := w
+    return 1
+  0
+# ==== annotated locals ====
+# Annotated local declarations: `name: Type := value` fixes the local's type to
+# the annotation. The value converts to it exactly as it would for a parameter of
+# that type (a union member into its enum, `T` into `T?`, `null` into `T?`), and
+# a later `name = value` is checked and converted against the same type.
+record Circle(r: Float)
+record Region(w: Float, h: Float)
+enum Shape = Circle | Region
+error LocalError = Bad | Worse
+fun area(s: Shape) -> Float =
+  match s
+    Circle(r) => r * r * 3.0
+    Region(w, h) => w * h
+fun parseLocal(n: Int) -> LocalError!Int =
+  if n < 0
+    return error.Bad
+  n * 2
+fun twice(x: Int) -> Int = x * 2
+fun same(x: T) -> T =
+  y: T := x
+  y
+# ==== structs records tests ====
 test "struct assignment copies"
   a := Vec2(x: 1.0, y: 2.0)
   b := a
@@ -299,12 +372,83 @@ test "init lists are fresh per construction"
   assert b.items.length() == 0
 test "a record embeds another: fields, init and methods are copied"
-  s := Scoreboard(start: 5, name: "hi")
+  s := Scoreboard(count: 5, name: "hi")
   assert s.count == 5
   s.bump()
   assert s.count == 6
   assert s.best == 0
 test "override replaces an embedded method and self.X.m() calls the original"
-  s := Scoreboard(start: 1, name: "hi")
+  s := Scoreboard(count: 1, name: "hi")
   assert s.show() == "hi: counter 1"
+# ==== digit names tests ====
+test "digit_variant_match"
+  assert asInt(A1(n: 5)) == 5
+  x := B2
+  assert asInt(x) == 0
+test "digit_variant_pattern_if"
+  assert payload(A1(n: 7)) == 7
+  assert payload(B2) == 0
+  w := B2
+  assert isB2(w) == 1
+  assert isB2(A1(n: 1)) == 0
+test "digit_error_names"
+  a := fail(3) catch 0
+  assert a == 3
+  b := fail(1) catch 9
+  assert b == 9
+test "digit_enum_const_still_works"
+  assert V2.K1 == 40
+  assert Int.Max > 0
+# ==== annotated locals tests ====
+test "union_local"
+  s: Shape := Circle(r: 2.0)
+  assert area(s) == 12.0
+test "union_local_reassigned"
+  s: Shape := Circle(r: 1.0)
+  s = Region(w: 2.0, h: 3.0)
+  assert area(s) == 6.0
+test "optional_local_present"
+  o: Int? := 4
+  assert {o ?: 0} == 4
+test "optional_local_null"
+  o: Int? := null
+  assert {o ?: 9} == 9
+  o = 5
+  assert {o ?: 9} == 5
+test "list_local"
+  xs: Slice[Shape] := Slice[Shape]()
+  xs.push(Circle(r: 1.0))
+  xs.push(Region(w: 1.0, h: 1.0))
+  assert xs.length() == 2
+test "fn_local"
+  f: fn(Int) -> Int := twice
+  assert f(4) == 8
+test "scalar_locals"
+  n: Int := 3
+  x: Float := 2.5
+  assert n + 1 == 4
+  assert x * 2.0 == 5.0
+test "generic_param_annotation"
+  assert same(7) == 7
+  assert same("a") == "a"
+test "named_error_set_local"
+  ok: LocalError!Int := parseLocal(4)
+  bad: LocalError!Int := parseLocal(-1)
+  assert {ok catch 0} == 8
+  assert {bad catch 7} == 7

plum-examples/tail_calls.plum DELETED Viewed

@@ -1,110 +0,0 @@
-# Tail calls: deep recursion that must not overflow the stack.
-#
-# Self tail calls compile to loops, other tail calls use `return_call`, and a
-# constructor wrapped self call (`Cons(head: f(h), tail: map(t, f))`) is rewritten
-# to a loop (tail recursion modulo cons). All deep tests use 1,000,000 steps.
-module tail_calls
-import std/Int
-import std/Float
-import std/List
-fun sumTo(n: Int, acc: Int) -> Int =
-  if n == 0 then acc else sumTo(n - 1, acc + n)
-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) -> List[Int] =
-  if a >= b then Nil else Cons(head: a, tail: fromTo(a + 1, b))
-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: 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: List[T], acc: Int) -> Int = match xs
-  Nil => acc
-  Cons(_, t) => length(t, acc + 1)
-fun isEven(n: Int) -> Bool =
-  if n == 0 then true else isOdd(n - 1)
-fun isOdd(n: Int) -> Bool =
-  if n == 0 then false else isEven(n - 1)
-# `call` tail calls a closure value; `dec` tail calls `call`.
-fun call(f: fn(Int) -> Int, n: Int) -> Int = f(n)
-fun dec(n: Int) -> Int =
-  if n == 0 then 0 else call(dec, n - 1)
-own record Counter(n: Int, total: Int)
-fun spin(own c: Counter) -> Counter =
-  if c.n == 0 then c else spin(Counter(..c, n: c.n - 1, total: c.total + 2))
-fun depth(n: Int) -> Int =
-  if n == 0 then 0 else 1 + depth(n - 1)
-fun down(n: Int) -> error{Neg}!Int =
-  if n < 0
-    return error.Neg
-  if n == 0
-    return 5
-  down(n - 1)
-test "tail_sum_million"
-  assert sumTo(1000000, 0) == 500000500000
-test "tail_build_million"
-  assert length(build(1000000, Nil), 0) == 1000000
-test "fold_million"
-  xs := fromTo(0, 1000000)
-  assert foldl(xs, 0, |a, x| a + x) == 499999500000
-test "mutual_even_odd_million"
-  assert isEven(1000000)
-  assert !isOdd(1000000)
-  assert isOdd(999999)
-test "trmc_map_million"
-  ys := map(fromTo(0, 1000000), |x| x + 1)
-  assert length(ys, 0) == 1000000
-  assert foldl(ys, 0, |a, x| a + x) == 500000500000
-test "trmc_fromTo_million"
-  xs := fromTo(0, 1000000)
-  assert length(xs, 0) == 1000000
-test "closure_tail_million"
-  assert dec(1000000) == 0
-test "own_record_loop_100k"
-  c := spin(Counter(n: 100000, total: 0))
-  assert c.n == 0
-  assert c.total == 200000
-test "recursive_closure_million"
-  go := |n, acc| if n == 0 then acc else go(n - 1, acc + n)
-  assert go(1000000, 0) == 500000500000
-test "closure_body_tail_million"
-  fin := |n: Int| sumTo(n, 0)
-  assert fin(1000000) == 500000500000
-test "error_union_loop_million"
-  assert { down(1000000) catch 99 } == 5
-test "map_single_pass_million"
-  ys := map(fromTo(0, 1000000), |x| x * 2)
-  assert foldl(ys, 0, |a, x| a + x) == 999999000000
-# Non-tail recursion still uses the wasm stack. Measured limit under the 4 MiB
-# host stack: about 265,000 frames (260,000 passes, 270,000 traps) of `1 + depth(n - 1)`; tested well below it.
-test "tree_recursion_depth_recorded"
-  assert depth(100000) == 100000

plum-examples/testing.plum DELETED Viewed

@@ -1,20 +0,0 @@
-# Testing: native `test "name"` blocks and `assert` statements executed by
-# the `plum test` runner.
-import std/Str
-import std/Int
-import std/Float
-fun add(a: Int, b: Int) -> Int =
-  a + b
-fun isEven(n: Int) -> Bool =
-  n % 2 == 0
-test "add works"
-  assert add(1, 2) == 3
-  assert add(2, 2) == 4
-test "isEven works"
-  assert isEven(4)
-  assert !isEven(3)
-  assert isEven(2)

plum-examples/trait_scene.plum DELETED Viewed

@@ -1,50 +0,0 @@
-# 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/Slice
-trait Entity(x: Int, y: Int) =
-  fun update(self, dt: Int)
-  fun draw(self) -> Int
-  fun hit(self, px: Int, py: Int) -> Bool = px == self.x && py == self.y
-record House(Entity(x, y), floors: Int) =
-  override fun update(self, dt: Int) =
-    return
-  override fun draw(self) -> Int = self.floors * 10
-record Walker(Entity(x, y), speed: Int) =
-  override fun update(self, dt: Int) =
-    self.x = self.x + self.speed * dt
-  override fun draw(self) -> Int = self.x
-record Scene(entities: Slice[Entity]) =
-  fun update(self, dt: Int) =
-    for e := range self.entities
-      e.update(dt)
-  fun drawAll(self) -> Int =
-    total := 0
-    for e := range self.entities
-      total = total + e.draw()
-    total
-fun makeScene() -> Scene =
-  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)
-test "scene_updates_and_draws"
-  s := makeScene()
-  assert s.drawAll() == 23
-  s.update(5)
-  assert s.drawAll() == 33
-test "scene_hit_default"
-  s := makeScene()
-  assert s.entities.at(1).hit(3, 1)
-  s.update(1)
-  assert s.entities.at(1).hit(5, 1)
-  assert !s.entities.at(0).hit(1, 1)

plum-examples/traits.plum CHANGED Viewed

@@ -1,19 +1,22 @@
+# Traits: fields, defaults, dispatch and a pure scene.
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+# ==== traits ====
 # Traits: `trait Entity(pos: Vec2, z: Int) = ...` bundles fields and methods. A
 # `record` embeds traits by listing them first in its field list, gains their
 # fields and default methods, and converts to each trait where one is expected.
 # `Entity(pos, z)` exposes those trait fields as constructor parameters; a bare
 # `Entity` exposes none, so the trait's or record's `fun init(self)` must set them.
 # A method without a body is required; one with a body is a default.
-module traits
-import std/Str
-import std/Int
-import std/Float
-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)
-trait Entity(pos: Vec2, z: Int) =
+trait Entity(mut pos: Vec2, mut z: Int) =
   fun update(self, dt: Int) -> Int
   fun draw(self) -> Int
   fun moveBy(self, d: Vec2) =
@@ -52,6 +55,44 @@ fun describe(e: Entity) -> Int =
     House(_, _, _, kind) => kind
     _ => -1
+# ==== trait scene ====
+# A tiny pure scene: a `Scene` holds `Slice[Actor]`; the engine side knows only
+# the trait, the records fill it in. No game host needed.
+trait Actor(mut x: Int, y: Int) =
+  fun update(self, dt: Int)
+  fun draw(self) -> Int
+  fun hit(self, px: Int, py: Int) -> Bool = px == self.x && py == self.y
+record Hut(Actor(x, y), floors: Int) =
+  override fun update(self, dt: Int) =
+    return
+  override fun draw(self) -> Int = self.floors * 10
+record Walker(Actor(x, y), speed: Int) =
+  override fun update(self, dt: Int) =
+    self.x = self.x + self.speed * dt
+  override fun draw(self) -> Int = self.x
+record Scene(entities: Slice[Actor]) =
+  fun update(self, dt: Int) =
+    for e := range self.entities
+      e.update(dt)
+  fun drawAll(self) -> Int =
+    total := 0
+    for e := range self.entities
+      total = total + e.draw()
+    total
+fun makeScene() -> Scene =
+  es: Slice[Actor] := Slice[Actor]()
+  es.push(Hut(x: 0, y: 0, floors: 2))
+  es.push(Walker(x: 3, y: 1, speed: 2))
+  Scene(entities: es)
+# ==== traits tests ====
 test "fields_through_trait"
   h := house()
   e: Entity := h
@@ -96,3 +137,18 @@ test "header_selection_init_and_internal_field"
   assert c.update(1) == 9
   e: Entity := c
   assert e.draw() == 9
+# ==== trait scene tests ====
+test "scene_updates_and_draws"
+  s := makeScene()
+  assert s.drawAll() == 23
+  s.update(5)
+  assert s.drawAll() == 33
+test "scene_hit_default"
+  s := makeScene()
+  assert s.entities.at(1).hit(3, 1)
+  s.update(1)
+  assert s.entities.at(1).hit(5, 1)
+  assert !s.entities.at(0).hit(1, 1)

plum-examples/typed_arrays.plum DELETED Viewed

@@ -1,39 +0,0 @@
-# Typed arrays: unboxed native `Array[Int]` and `Array[Float]` lowering to
-# WebAssembly primitive arrays, along with flat 2D `Grid[T]`.
-module typed_arrays
-import std/Int
-import std/Float
-import std/Array
-import std/Grid
-import std/Seq
-# Tile-grid style data: Array[Int] / Array[Float] / Array[Bool] are native
-# unboxed wasm arrays (i64 / f64 / i32 elements), not boxed anyref arrays.
-fun sumInts(n: Int) -> Int =
-  a := Array.filled(n, 3)
-  total := 0
-  for i := range n
-    total = total + a.get(i)
-  return total
-fun sumFloats(n: Int) -> Float =
-  a := Array.filled(n, 0.5)
-  total := 0.0
-  for i := range n
-    total = total + a.get(i)
-  return total
-fun countTrue(n: Int) -> Int =
-  a := Array.filled(n, false)
-  a.set(1, true)
-  a.set(3, true)
-  c := 0
-  for i := range n
-    if a.get(i)
-      c = c + 1
-  return c
-test "array_int_native: filled arrays hold their values"
-  assert sumInts(10) == 30
-  assert sumFloats(4) == 2.0
-  assert countTrue(5) == 2

plum-examples/unboxed_variants.plum CHANGED Viewed

@@ -1,6 +1,6 @@
 # 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
+# List of unions, member mutation, reassignment across members, record
 # members, and enum `init` versus variant-name resolution.
 module unboxed_variants
 import std/Str
@@ -175,9 +175,9 @@ 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 Circle(mut r: Float)
-record Rect(w: Float, h: Float)
+record Rect(mut w: Float, h: Float)
 enum Shape = Circle | Rect
@@ -200,13 +200,13 @@ fun kind(s: Shape) -> Int =
     Circle(_) => 1
     Rect(_, _) => 10
-own record Token(id: Int)
+record Token(id: Int)
-own record Stamp(id: Int, note: Str)
+record Stamp(id: Int, note: Str)
 enum Mark = Token | Stamp
-fun takeMark(own m: Mark) -> Mark = m
+fun takeMark(m: Mark) -> Mark = m
 fun markId(m: Mark) -> Int =
   match m