775bbeb | plum | pyrossh

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

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

775bbeb — Peter John 2026-11-03T15:44:05+05:30

Recursive state/view; fix param reassignment codegen; own record docs

Files changed (12) hide show

README.md +56 -4
docs/plans/2026-11-03-own-record.benchmark.md +11 -0
docs/plans/2026-11-03-own-record.incidents.jsonl +84 -0
docs/plans/2026-11-03-own-record.md +32 -0
docs/plans/2026-11-03-own-record.progress.md +117 -0
docs/plans/2026-11-03-own-record.report.json +342 -0
docs/plans/2026-11-03-own-record.report.md +49 -0
plum-examples/game_state_view.plum +208 -162
plum-game/web-test/fixtures/stress_state_view.plum +88 -75
plum-std/game/Picture.plum +163 -159
plum-wasm-codegen/src/lib.rs +9 -1
plum-wasm-codegen/tests/own_inplace_e2e_test.rs +50 -0

README.md CHANGED Viewed

@@ -631,6 +631,58 @@ w.draw()                            # World.draw: prints "stage" then "world"
 Every method that implements a trait's required method, replaces a trait default or replaces an embedded record's method must be `override fun`; defining one without it is an error (`World.draw hides Stage.draw; mark it override`), and so is an `override fun` that overrides nothing. Inside a record, `self.Owner.method(args)` calls the original from the embedded record or trait `Owner`.
+### Own records
+An `own record` (or `own trait`) is a value with a single owner, so the compiler can update it in place instead of copying. Ordinary records are unchanged; ownership is a property of the type. A plain parameter only borrows (read-only); an `own` parameter or `own self` takes the value, and the caller can't use it afterwards:
+```plum
+import std/Int
+import std/Float
+import std/List
+own record Cell(x: Float) =
+  fun step(own self) -> Cell = Cell(..self, x: self.x + 1.0)
+  fun peek(self) -> Float = self.x
+fun bump(own s: Cell) -> Cell =
+  t := Cell(..s, x: s.x + 1.0)
+  t
+fun read(c: Cell) -> Float = c.peek()
+record World(cell: Cell)
+fun advance(w: World) =
+  w.cell = w.cell.step()
+test "own"
+  c := Cell(x: 1.0)
+  d := bump(c)
+  assert {read(d) - 2.0}.abs() < 1e-6
+  w := World(cell: Cell(x: 0.0))
+  advance(w)
+  assert {w.cell.x - 1.0}.abs() < 1e-6
+  xs := List(Cell(x: 1.0), Cell(x: 2.0))
+  ys := xs.mapInPlace(|k| Cell(..k, x: k.x + 1.0))
+  assert {ys.at(1).x - 3.0}.abs() < 1e-6
+```
+- **What moves:** passing a value to an `own` parameter, calling an `own self` method, returning it, storing it in a field or list, and `match`ing on an owned value (the match consumes it). **What borrows:** plain parameters and plain `self`, and reads such as `s.x`.
+- **Spread writes in place:** `Cell(..s, x: s.x + 1.0)` where `s` is owned reuses `s`'s storage and writes the changed fields into it, so no new record is allocated. Spreading a borrowed or ordinary record still copies.
+- **Swap form:** you can't move a field out of a record, so replace it with a method call that takes and returns it: `w.cell = w.cell.step()` (in a game, `w.stage = w.stage.frame(dt, inputs).intoStage()`).
+- **Lists:** `List.mapInPlace` rewrites every element, and `takeAt(i)` / `putAt(i, v)` move one element out and back. See [`plum-examples/own_list.plum`](plum-examples/own_list.plum).
+The ownership checker reports mistakes at compile time:
+```
+"s" used after it was moved at 12:3
+cannot assign field "x" of borrowed "s"
+cannot store borrowed "s"; pass it with own or move it
+cannot move out of field "stage" of "w"; use the swap form
+```
+Embedding an own record or trait makes the embedding record own.
 ### Methods, `self` and field access
 A `fun` declared indented directly inside an `enum`, `struct` or `record` body whose first parameter is `self` is a method, called on a value (`c.getAge()`). One without `self` is a static function, called on the type (`Cat.named("Tom")`), and can't use `self`. Calling a static on a value, or a method on the type, is an error:
@@ -1246,7 +1298,7 @@ The page calls `init` once after the assets are loaded, then `update` and `draw`
 ### Pure scene graph
-The pure scene graph is the same kind of tree as `std/game/Scene`, but every function returns a new value and nothing is changed in place. It is split into four modules: `std/game/Actions` (timed actions such as `forever(rotateBy(...))`), `std/game/PureScene` (the `Actor` trait and its leaves, `group`, `sprite`, `button`, and the draw walk), `std/game/SceneTree` (update, hit testing, paths and event routing) and `std/game/SceneInput` (`Stage`, pointer capture and `UiEvent`). A game imports them by name:
+The pure scene graph is the same kind of tree as `std/game/Scene`, but a function never changes a value it was only given: updates take an owned actor (`own self`, `own` parameters, see [Own records](#own-records)), change it in place and hand it back, so no `clone()` is needed. `Actor` is an `own trait` and `Group`, `Sprite`, `Label`, `Button` and `Stage` are `own record`s. The graph is split into four modules: `std/game/Actions` (timed actions such as `forever(rotateBy(...))`), `std/game/PureScene` (the `Actor` trait and its leaves, `group`, `sprite`, `button`, and the draw walk), `std/game/SceneTree` (update, hit testing, paths and event routing) and `std/game/SceneInput` (`Stage`, pointer capture and `UiEvent`). A game imports them by name:
 ```
 import std/game/Actions
@@ -1272,8 +1324,7 @@ export fun init() -> World =
 export fun update(w: World, dt: Float) =
   inputs := SceneInput.pollPointer(w.wasDown)
   w.wasDown = isMouseDown(0)
-  h := w.stage.frame(dt, inputs)
+  w.stage = w.stage.frame(dt, inputs).intoStage()
-  w.stage = h.stage
 export fun draw(w: World) =
   w.stage.draw()
@@ -1281,7 +1332,8 @@ export fun draw(w: World) =
 - **Immediate mode** ([`game.plum`](plum-examples/game.plum)): one state record and a `draw` that issues the calls every frame. Use it for flat arcade games with a few kinds of thing.
 - **Scene** ([`game_scene.plum`](plum-examples/game_scene.plum)): a retained tree of mutable actors. Use it when you want objects that change in place and a familiar `act`/`draw` object model.
-- **Pure scene** ([`game_pure_scene.plum`](plum-examples/game_pure_scene.plum)): every update returns new values, pointer clicks arrive as `UiEvent`s, and the rules can be tested without a host. Use it when you want pure updates and tests that run without a game host.
+- **Pure scene** ([`game_pure_scene.plum`](plum-examples/game_pure_scene.plum)): every update takes an owned value and hands it back, pointer clicks arrive as `UiEvent`s, and the rules can be tested without a host. Use it when you want pure updates and tests that run without a game host.
+- **State/view** ([`game_state_view.plum`](plum-examples/game_state_view.plum)): the game state is plain data and a `view` turns it into `std/game/Picture`, a recursive picture type drawn by recursive functions. Use it when you want to draw from state instead of keeping a tree of actors.
 **Browser check:** `cargo run --manifest-path plum-game/web-test/Cargo.toml -- plum-examples/game.plum --screenshot /tmp/orb-run.png` builds the static web version, serves it and drives headless Chromium (software WebGPU; `--browser webkit` drives Playwright's WebKit, the Safari engine, instead) through [playwright-rs](https://crates.io/crates/playwright-rs): it fails if the canvas stays blank or stops changing, or the page logs an error, and reports whether audio started. It also takes `--assets DIR`, `--require-audio`, `--measure SECS` (with `--json`, `draws` is the GPU draw calls per frame), `--headed`, `--dpr N` (a device pixel ratio of N), `--lose-device` (destroys the GPU device after a few frames and requires rendering to resume) and `--expect-pixel x,y,r,g,b[,tol]` (repeatable; the screenshot pixel at CSS (x, y)), `--expect-unsupported-webgpu` (hides `navigator.gpu` and requires the page's "WebGPU is not supported" message while plum.wasm still loads) and `--no-module-introspection` (makes `WebAssembly.Module.imports/exports/customSections` throw, as Safari does). `plum-game/web-test/fixtures/` has `interleave.plum`, `text_sizes.plum` and `rendertarget.plum` for these. One-time setup: `cargo run --manifest-path plum-game/web-test/Cargo.toml --example install-browsers`. See [`plum-game/web-test/README.md`](plum-game/web-test/README.md); `docs/game.png` above was made with `--screenshot`. [`plum-game/web-test/BENCHMARK.md`](plum-game/web-test/BENCHMARK.md) records the renderer benchmark that led to this design.

docs/plans/2026-11-03-own-record.benchmark.md CHANGED Viewed

@@ -12,6 +12,17 @@ with the current debug `plum`, so phase B includes the in-place spread codegen a
 | stress_pure_scene, phase B (own record) | 2.107 / 1.931 | 2.00 / 1.90 | 2.70 / 2.30 | 4.10 / 2.50 | 0.343 / 0.316 | 1.26 |
 | stress_state_view (Picture, tree rebuilt per frame) | 2.132 / 2.066 | 2.10 / 2.00 | 2.30 / 2.20 | 4.30 / 4.20 | 0.08 | 1.61 |
+After the rebase onto master 05f8c38, recursive state/view (T14/T15: inline-variant `SceneNode`, `Nodes = End | More`, recursive `draw`/`step`/`view`, state in `Link[T]` lists of at most 700), same session:
+| fixture | avg ms | p50 | p95 | p99 | update ms | draw ms |
+|---|---|---|---|---|---|---|
+| stress_scene (mutable) | 1.729 | 1.70 | 1.90 | 2.00 | 0.040 | 1.28 |
+| stress_state_view, recursive | 1.905 / 1.908 | 1.90 | 2.30 | 2.40 | 0.05 | 1.49 |
+The recursive version is faster than the List-based state/view (avg 1.91 vs 2.07–2.13), and its p99 tail is gone (2.4 vs 4.2 ms).
+Against the mutable scene: avg +10%, p95 +21%. The remaining gap is the per-frame tree rebuild in draw (+0.2 ms).
+Tail calls and, later, a supercompiler (fusing `view` into `draw`, so no tree is built) are the next levers.
 Bar (review plan): average within 10% and p95 within 15% of the mutable scene, same session.
 - Phase B: avg +11% to +21%, p95 +21% to +42%: **missed**. Update time is unchanged from phase A (about 0.32 ms).

docs/plans/2026-11-03-own-record.incidents.jsonl ADDED Viewed

@@ -0,0 +1,84 @@
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum-pure-scene-values; ./target/debug/plum compile plum-game/web-test/fixtur"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum-pure-scene-values; cargo test -p plum-game --test host_test pureScene 2"}
+{"file": "docs/", "line": 0, "context": "T1: change outside Owns blocked by checkpoint; nothing saved: 1 files under docs/, first 1: docs/plans/2026-11-02-own-record.review.md", "agent": "checkpoint", "kind": "exception", "resolution": "open", "time": "14:40:41"}
+{"file": "plum-core/", "line": 0, "context": "T1: change outside Owns blocked by checkpoint; nothing saved: 5 files under plum-core/, first 5: plum-core/src/ctors.rs, plum-core/src/embeds.rs, plum-core/src/forms.rs, plum-core/src/traits.rs, plum…", "agent": "checkpoint", "kind": "exception", "resolution": "open", "time": "14:40:52"}
+{"file": "-", "line": 0, "context": "exit code 101: error: could not compile `plum-wasm-codegen` (lib) due to 2 previous errors", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "14:41:14"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum-pure-scene-values; cargo test -p plum-core 21 | grep -E  test result|FA"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum-pure-scene-values; cargo test -p plum-core --test own_parse_test own_rec"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum-pure-scene-values; cargo test -p plum-core --test own_parse_test 21 | g"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum-pure-scene-values; cargo test -p plum-core --test own_parse_test > .supe"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum-pure-scene-values; cargo test -p plum-core --test own_parse_test 21 | g"}
+{"file": "-", "line": 0, "context": "exit code 1: For more information, try '--help'.", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "14:42:19"}
+{"file": "", "line": 0, "context": "verified: seam T1↔T2", "agent": "pt_review", "kind": "verified", "time": "14:43:13"}
+{"file": "docs/plans/2026-11-03-own-record.md", "line": 177, "context": "seam T10↔T11: T10 Produces: Picture.draw: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "14:45:30"}
+{"file": "docs/plans/2026-11-03-own-record.md", "line": 177, "context": "seam T10↔T11: T10 Produces: Picture.bounds: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "14:45:30"}
+{"file": "docs/plans/2026-11-03-own-record.md", "line": 177, "context": "seam T10↔T11: T10 Produces: Picture.hitPath: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "14:45:30"}
+{"file": "plum-core/", "line": 0, "context": "T12: change outside Owns blocked by checkpoint; nothing saved: 2 files under plum-core/, first 2: plum-core/src/embeds.rs, plum-core/src/traits.rs", "agent": "checkpoint", "kind": "exception", "resolution": "open", "time": "14:47:49"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum-pure-scene-values; cargo test -p plum-checker --test ownership_moves_tes"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum-pure-scene-values; cargo test -p plum-checker --test ownership_moves_tes"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: touch plum-wasm-codegen/src/lib.rs && cargo test -q -p plum-wasm-codegen --test own_inplace_e2e_test"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum-pure-scene-values/plum-wasm-codegen && cargo test -q -p plum-wasm-codege"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum-pure-scene-values/plum-wasm-codegen && cargo test -q -p plum-wasm-codege"}
+{"file": "plum-checker/src/ownership.rs", "line": 1, "context": "Assign and ClassCall carry no source position; move/use errors use the nearest FnCall or statement position, columns approximate", "agent": "T4", "kind": "workaround", "time": "14:50:38"}
+{"file": "", "line": 0, "context": "verified: seam T3↔T4", "agent": "pt_review", "kind": "verified", "time": "14:50:51"}
+{"file": "", "line": 0, "context": "verified: seam T11↔T12", "agent": "pt_review", "kind": "verified", "time": "14:50:51"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cargo test -q -p plum-checker --test ownership_moves_test 21 | tail -8"}
+{"file": "-", "line": 0, "context": "own_spread_reuses_object: failed", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "14:52:35"}
+{"file": "-", "line": 0, "context": "exit code 1: For more information, try '--help'.", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "14:52:40"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cargo test -p plum-checker --test ownership_flow_test 21 | grep -E  ^test |panicked|error  | head -"}
+{"file": "-", "line": 0, "context": "own_spread_reuses_object: failed", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "14:53:03"}
+{"file": "-", "line": 0, "context": "own_self_field_write: failed", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "14:53:03"}
+{"file": "-", "line": 0, "context": "own_spread_sets_fields: failed", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "14:53:03"}
+{"file": "-", "line": 0, "context": "own_spread_swap_reads_old_values: failed", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "14:53:03"}
+{"file": "-", "line": 0, "context": "own_trait_record_spread_in_place: failed", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "14:53:03"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cargo test -q -p plum-wasm-codegen --test own_inplace_e2e_test own_spread_sets_fields 21 | tail -20"}
+{"file": "-", "line": 0, "context": "exit code 101: warning: [email protected]: plum-tooling/vscode-plum/out/extension.js not found (run `npm install && npm run build` there); `plum editor vscode` wil", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "14:55:03"}
+{"file": "-", "line": 0, "context": "exit code 101: warning: [email protected]: plum-tooling/vscode-plum/out/extension.js not found (run `npm install && npm run build` there); `plum editor vscode` wil", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "14:55:10"}
+{"file": "-", "line": 0, "context": "variadic_own_param_takes_every_arg: failed", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "14:56:31"}
+{"file": "-", "line": 0, "context": "own_spread_reuses_object: failed", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "14:56:44"}
+{"file": "-", "line": 0, "context": "own_spread_sets_fields: failed", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "14:56:44"}
+{"file": "-", "line": 0, "context": "own_spread_swap_reads_old_values: failed", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "14:56:44"}
+{"file": "-", "line": 0, "context": "own_spread_reuses_object: failed", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "14:57:15"}
+{"file": "-", "line": 0, "context": "own_spread_swap_reads_old_values: failed", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "14:57:15"}
+{"file": "-", "line": 0, "context": "own_spread_sets_fields: failed", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "14:57:15"}
+{"file": "", "line": 0, "context": "verified: seam T3↔T4", "agent": "pt_review", "kind": "verified", "time": "14:58:35"}
+{"file": "", "line": 0, "context": "verified: seam T4↔T5", "agent": "pt_review", "kind": "verified", "time": "14:58:35"}
+{"file": "plum-checker/src/ownership.rs", "line": 700, "context": "Any program containing an own record makes checker flag Int/Float params stored into locals in std/Str.plum etc: cannot store borrowed charIndex (k := charIndex). Store check must apply only to own-t…", "agent": "T6", "kind": "exception", "time": "15:04:21"}
+{"file": "-", "line": 0, "context": "own_spread_reuses_object: failed", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "15:06:00"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cargo test -p plum-checker --test ownership_flow_test --test ownership_moves_test 21 | grep -E  tes"}
+{"file": "-", "line": 0, "context": "exit code 1: For more information, try '--help'.", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "15:06:18"}
+{"file": "-", "line": 0, "context": "own_spread_reuses_object: failed", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "15:06:20"}
+{"file": "-", "line": 0, "context": "own_spread_reuses_object: failed", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "15:06:47"}
+{"file": "-", "line": 0, "context": "std_str_checks_with_own_present: failed", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "15:07:09"}
+{"file": "-", "line": 0, "context": "own_trait_record_spread_in_place: failed", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "15:07:46"}
+{"file": "", "line": 0, "context": "verified: seam T4↔T5", "agent": "pt_review", "kind": "verified", "time": "15:07:59"}
+{"file": "-", "line": 0, "context": "exit code 1: For more information, try '--help'.", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "15:08:25"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum-pure-scene-values; cargo test -p plum-wasm-codegen --test own_inplace_e2"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum-pure-scene-values; cargo test -p plum-wasm-codegen --no-run 21 | grep E"}
+{"file": "", "line": 0, "context": "verified: seam T3↔T6", "agent": "pt_review", "kind": "verified", "time": "15:11:59"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: sed -i 's/if let Some((true, field)) = accessorField(&c.name) {/if let Some((true, field)) = accesso"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cargo test -p plum-wasm-codegen --test own_inplace_e2e_test 21 | grep -E  ^test |test result|panick"}
+{"file": "-", "line": 0, "context": "exit code 1: For more information, try '--help'.", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "15:15:26"}
+{"file": "", "line": 0, "context": "verified: seam T6↔T7", "agent": "pt_review", "kind": "verified", "time": "15:15:42"}
+{"file": "", "line": 0, "context": "verified: seam T5↔T7", "agent": "pt_review", "kind": "verified", "time": "15:15:42"}
+{"file": "", "line": 0, "context": "verified: seam T4↔T5", "agent": "pt_review", "kind": "verified", "time": "15:16:54"}
+{"file": "", "line": 0, "context": "verified: seam T5↔T7", "agent": "pt_review", "kind": "verified", "time": "15:16:54"}
+{"file": "", "line": 0, "context": "verified: seam T3↔T6", "agent": "pt_review", "kind": "verified", "time": "15:16:54"}
+{"file": "", "line": 0, "context": "verified: seam T6↔T7", "agent": "pt_review", "kind": "verified", "time": "15:16:54"}
+{"file": "", "line": 0, "context": "verified: seam T1↔T8", "agent": "pt_review", "kind": "verified", "time": "15:20:37"}
+{"file": "docs/plans/2026-11-03-own-record.md", "line": 140, "context": "seam T7↔T8: T7 Produces: List.take: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "15:20:37"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum-pure-scene-values; cargo test -p plum-checker 21 | grep -E  test result"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum-pure-scene-values; ./target/debug/plum test plum-std/game/PureScene.plum"}
+{"file": "", "line": 0, "context": "verified: seam T4↔T5", "agent": "pt_review", "kind": "verified", "time": "15:24:18"}
+{"file": "", "line": 0, "context": "verified: seam T5↔T7", "agent": "pt_review", "kind": "verified", "time": "15:24:18"}
+{"file": "", "line": 0, "context": "verified: seam T8↔T9", "agent": "pt_review", "kind": "verified", "time": "15:24:40"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cargo test -p plum-core -p plum-checker -p plum-wasm-codegen 21 | grep -E '^test result|FAILED|pani"}
+{"file": "", "line": 0, "context": "verified: seam T12↔T14", "agent": "pt_review", "kind": "verified", "time": "15:35:01"}
+{"file": "", "line": 0, "context": "verified: seam T9↔T13", "agent": "pt_review", "kind": "verified", "time": "15:35:36"}
+{"file": "", "line": 0, "context": "verified: seam T11↔T15", "agent": "pt_review", "kind": "verified", "time": "15:40:19"}
+{"file": "", "line": 0, "context": "verified: seam T12↔T15", "agent": "pt_review", "kind": "verified", "time": "15:40:19"}
+{"file": "docs/plans/2026-11-03-own-record.md", "line": 221, "context": "seam T14↔T15: T14 Produces: Picture.draw: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "15:40:19"}
+{"file": "docs/plans/2026-11-03-own-record.md", "line": 221, "context": "seam T14↔T15: T14 Produces: Picture.bounds: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "15:40:19"}
+{"file": "docs/plans/2026-11-03-own-record.md", "line": 221, "context": "seam T14↔T15: T14 Produces: Picture.hitPath: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "15:40:19"}
+{"file": "", "line": 0, "context": "verified: seam T6↔T7", "agent": "pt_review", "kind": "verified", "time": "15:41:35"}
+{"file": "", "line": 0, "context": "verified: seam T3↔T6", "agent": "pt_review", "kind": "verified", "time": "15:41:35"}

docs/plans/2026-11-03-own-record.md CHANGED Viewed

@@ -47,6 +47,8 @@ flowchart LR
   T11[state/view game]
   T12[state/view fixture]
   T13[docs]
+  T14[recursive Picture]
+  T15[recursive state/view]
   %% taskgraph
   T1 --> T2
   T3 --> T4
@@ -60,6 +62,10 @@ flowchart LR
   T10 --> T11
   T11 --> T12
   T9 --> T13
+  T12 --> T14
+  T11 --> T15
+  T12 --> T15
+  T14 --> T15
 ```
 ## Migration
@@ -210,6 +216,31 @@ e.g. `Picture.hitPath(Group([], [RectShape(0.0, 0.0, 10.0, 10.0, c)]), 50.0, 50.
 **Review Focus:** numeric: same actor count (about 5,750) and visual density as stress_pure_scene.
 **Test code:** web_check.rs `state_view_renders_and_animates` (mirrors pure_scene_renders_and_animates) passes in Chromium.
+## Recursive state/view (added after rebase; user request)
+### T14 recursive Picture · Complexity 4 · Est. context 40k
+**Owns:** plum-std/game/Picture.plum
+**Components:** 1
+**LOC owned:** 200
+**Tests:** fast
+**Model:** sonnet
+**Consumes:** none
+**Produces:** Picture.draw(node: SceneNode) · Picture.bounds(node: SceneNode) -> Rect · Picture.hitPath(node: SceneNode, x: Float, y: Float) -> List[Int]
+e.g. `Picture.hitPath(Group(Translate(10.0, 0.0), More(RectShape(0.0, 0.0, 10.0, 10.0, c), End)), 15.0, 5.0) -> [0]`
+**Review Focus:** deep: structural recursion only (no List indexing, no matrix stack list); parent matrix and alpha passed as args. numeric: same bounds/hit results as before.
+**Test code:** inline-variant enums: `enum SceneNode = Group(transform: Transform, children: Nodes) | Filter(effect: Effect, target: Int, child: SceneNode) | Sprite(..) | Text(..) | RectShape(..) | CircleShape(..) | LineShape(..)`, `enum Nodes = End | More(head: SceneNode, tail: Nodes)`, `enum Transform = Translate(..) | Rotate(..) | Scale(..) | Compose(first: Transform, then: Transform)`. draw/bounds/hitPath are recursive `= match` fns. Existing 5 test names keep their asserted values.
+### T15 recursive state/view game and fixture · Complexity 5 · Est. context 50k
+**Owns:** plum-examples/game_state_view.plum, plum-game/web-test/fixtures/stress_state_view.plum
+**Components:** 2
+**LOC owned:** 300
+**Tests:** slow
+**Model:** sonnet
+**Consumes:** Picture.hitPath(node: SceneNode, x: Float, y: Float) -> List[Int]
+**Produces:** none
+**Review Focus:** state: `Msg` inline-variant enum; `step(state, msg)` and `view(state)` recursive `= match`; id-keyed state folded recursively. Same gameplay and test names.
+**Test code:** game_state_view.plum keeps its 22 test names and values; stress_state_view.plum keeps 2 tests and 5,750 actors; web_check `state_view_renders_and_animates` passes.
 ## Docs
 ### T13 docs · Complexity 2 · Est. context 30k
@@ -229,3 +260,4 @@ e.g. `Picture.hitPath(Group([], [RectShape(0.0, 0.0, 10.0, 10.0, c)]), 50.0, 50.
 - std/game + examples: state, numeric. Risks: behaviour drift from phase A; Picture matrix order.
 **Probe entry:** run=./target/debug/plum test
 R4 gate: coordinator benchmarks T2; if it misses the bar, stop and report.
+Follow-ups (user, not in this plan): tail calls for the recursive Picture/state/view; a supercompiler later.

docs/plans/2026-11-03-own-record.progress.md ADDED Viewed

@@ -0,0 +1,117 @@
+# Phase B own-record run
+- start ea04e6cc77a758820e11f3544ec36d10ce77c6f2
+- Ruling: skip T0 Wave 0 skeleton - stubs cannot be generated for Plum/Rust compiler interfaces; consumers test real code behind taskgraph edges - cost if wrong: a consumer waits on its producer
+- Ruling: archived phase A run state to .superlite/archive/pure-scene-phase-a - lint froze T1-T9 against phase A's ledger - cost if wrong: none, files kept
+- Ruling: plan 16.7k chars over the 15k cap, accepted - 13 tasks of contracts; prime stays slim - cost if wrong: larger prime
+- unblocked: dispatched T1 T3 T10 at 14:38:12; waiting on fixes: none
+- Ruling: T3 may add isOwn/ownSelf: false at AST construction sites outside its Owns (plum-core ctors/embeds/forms/traits/union_lower, others) - adding struct fields breaks those literals - cost if wrong: checkpoint needs a manual docs-free commit of those sites
+- Ruling: T2 sent to T1's agent before T1's checkpoint - checkpoint blocked by T3's in-flight construction-site edits; T1 tests green - cost if wrong: T1 re-checkpointed later
+- T1 DONE_WITH_CONCERNS: host_test pureScene not run by agent (hook); coordinator runs it
+- tests fast passed=0 failed=1 skipped=0 seconds=2.4
+- Ruling: T10 Filter carries target: Int (game-created render target) - per-draw textureCreate leaked a texture per filter per frame, no destroy extern - cost if wrong: games manage one texture per filter
+- Ruling: T10 SceneNode flattened (RectShape|CircleShape|LineShape|Sprite|Text|Group|Filter), BlendFx name - nested Shape enum fails to type-check; Blend collides with Game - cost if wrong: none, same expressiveness
+- tests fast passed=0 failed=1 skipped=0 seconds=0.0
+- checkpoint T1 a0d9f9fe12 migrate phase A to master syntax
+- checkpoint T3 1b68156d83 own syntax
+- checkpoint T10 4b3d53c2cb std/game/Picture
+- unblocked: dispatched T4 T6 at 14:43:02 (T2 T11 already sent); waiting on fixes: none
+- Ruling: committed T3's 13 one-line construction-site defaults separately (1 commit) - checkpoint blocks files outside Owns - cost if wrong: one extra commit
+- checkpoint T2 03d3d3fb2a upper-bound probe fixture
+- checkpoint T11 c9368a7cda state/view Orb Run
+- R4 GATE TRIPPED 14:45: headed M3 Pro, measure 10. mutable avg 1.737/1.689 p95 1.9/1.8 upd 0.037; phase A avg 2.012 p95 2.5 upd 0.321; in-place upper bound avg 1.862/1.883 p95 2.3/2.3 upd 0.275/0.277. Bar avg<=+10% p95<=+15%: upper bound avg +7..11%, p95 +21..28% MISS; in-place removes only ~14% of update cost -> copies are not the main cost.
+- Ruling: per R4 stop compiler chain (T4 stopped, T6 not sent, T5 T7 T8 T9 held); continue state/view T11-T12 (independent) for the 5-row table; report to user - cost if wrong: compiler work delayed one round
+- T4 stopped: plum-checker/src/ownership.rs draft (uncompiled, unwired, untested); lowerings still drop isOwn; Assign/ClassCall lack positions (move error positions approximate)
+- Ruling: [scope] user chose 'build own record' after R4 gate tripped - resume T4, dispatch T6; continue full compiler chain - cost if wrong: phase B may still miss the bar (upper bound p95 +21..28%)
+- T12 DONE (checkpoint waits on T4 in-flight plum-core edits). state/view headed: avg 2.132/2.066 p95 2.3/2.2 p99 4.3/4.2 upd 0.081/0.074 draw 1.621/1.595 (view rebuild counted in draw)
+- tests fast passed=1 failed=0 skipped=0 seconds=54.4
+- checkpoint T4 d692a4a4f7 ownership checker: bindings and moves
+- checkpoint T12 f0933bd6ff state/view fixture and web check
+- tests fast passed=1 failed=0 skipped=0 seconds=42.3
+- unblocked: dispatched T5 (fresh) + package-reviewer on T4 at 14:51:21; waiting on fixes: none
+- Ruling: T4 reviewer is findings-only for ownership.rs (T5 edits it in parallel); fixes route to T5 - cost if wrong: one extra T5 round
+- tests fast passed=1 failed=0 skipped=0 seconds=55.7
+- tests fast passed=0 failed=1 skipped=0 seconds=4.3
+- tests fast passed=1 failed=0 skipped=0 seconds=5.4
+- tests fast passed=0 failed=1 skipped=0 seconds=0.0
+- T4 review DONE_WITH_CONCERNS: no straight-line bugs; plum-std+examples 579/0; 6 holes (field move-out, yield, ternary tails, variadic own, Bang/Catch/Try, inherited own self) routed to T5
+- Ruling: moving an own value out of a field (non-swap) errors 'cannot move out of field "<f>" of "<name>"; use the swap form' - partial moves untracked otherwise - cost if wrong: one more message text
+- tests fast passed=19 failed=5 skipped=0 seconds=15.6
+- tests fast passed=1 failed=0 skipped=0 seconds=15.6
+- tests fast passed=0 failed=1 skipped=0 seconds=0.3
+- tests fast passed=0 failed=1 skipped=0 seconds=1.6
+- tests fast passed=0 failed=1 skipped=0 seconds=1.2
+- tests fast passed=8 failed=1 skipped=0 seconds=0.4
+- tests fast passed=0 failed=3 skipped=0 seconds=9.8
+- tests fast passed=1 failed=0 skipped=0 seconds=52.4
+- tests fast passed=0 failed=3 skipped=0 seconds=5.1
+- tests fast passed=1 failed=0 skipped=0 seconds=4.0
+- checkpoint T4 95d5739e16 ownership checker: bindings and moves
+- checkpoint T5 5e9fcc30d1 ownership checker: branches, loops, closures, fields
+- T5 DONE: flow 16/16, moves 13/13. Ruling: accept deviations (loop error at move site; closures borrow-only incl. returning captures; field moves except exact swap; R2 only at/get/first/last on List[Own] params/annotated locals; R5 wasm test moved to T6 scope) - cost if wrong: narrower R2 coverage
+- T6 BLOCKED: checker false positive 'cannot store borrowed' on Int bindings whenever an own type exists -> F-T5-1 to fixer-sonnet (tier 1, known symptom, one module)
+- NOTE: single-letter uppercase type names (S) parse as generics; tests use Cell
+- tests fast passed=2 failed=1 skipped=0 seconds=6.8
+- tests fast passed=1 failed=0 skipped=0 seconds=40.1
+- tests fast passed=1 failed=0 skipped=0 seconds=0.3
+- tests fast passed=0 failed=1 skipped=0 seconds=0.0
+- tests fast passed=0 failed=1 skipped=0 seconds=2.0
+- tests fast passed=1 failed=0 skipped=0 seconds=0.3
+- tests fast passed=0 failed=1 skipped=0 seconds=2.7
+- tests fast passed=1 failed=0 skipped=0 seconds=0.3
+- tests fast passed=10 failed=1 skipped=0 seconds=15.0
+- tests fast passed=3 failed=0 skipped=0 seconds=24.0
+- tests fast passed=0 failed=1 skipped=0 seconds=2.0
+- tests fast passed=1 failed=0 skipped=0 seconds=0.5
+- tests fast passed=1 failed=0 skipped=0 seconds=0.4
+- checkpoint T5 86efd073f5 ownership checker: branches, loops, closures, fields
+- F-T5-1 FIXED (params of non-own type no longer tracked), T5 re-checkpointed 86efd07
+- F-T6-1 to fixer-sonnet-high: finish/verify T6 (implementer over 80k context); replace Debug-text hazard check with AST walk; add R5 match-arm test
+- tests fast passed=1 failed=0 skipped=0 seconds=0.3
+- tests fast passed=0 failed=1 skipped=0 seconds=0.1
+- tests fast passed=1 failed=0 skipped=0 seconds=19.5
+- checkpoint T6 575a969416 in-place spread codegen
+- T6 checkpointed 575a969 (own_inplace 8 pass 1 ignored; codegen suite green)
+- F-T6-2 to fixer-sonnet-high: own trait field setters (__set_) flagged as borrowed self; __set_ calls must count as field writes on receiver
+- unblocked: dispatched T7 to a53be28 at 15:12:21; waiting on fixes: F-T6-2
+- Ruling: [scope] List.take/put renamed takeAt/putAt - List.take shadowed the lazy Seq take adapter (forms.rs methodStar), breaking seq.plum - cost if wrong: naming only; T8 consumes takeAt/putAt
+- T7 sweep: at/get/first/last/head/findValue/sample alias; set old slot not invalidated; slice shares storage; removeAt/pop/takeAt leave stale slots; push/add/init/remove take plain T (follow-up: own-aware List API)
+- tests fast passed=0 failed=1 skipped=0 seconds=0.0
+- checkpoint T7 a167991594 List for owned elements
+- checkpoint T5 5b664337f4 ownership checker: branches, loops, closures, fields
+- checkpoint T6 58a9182174 in-place spread codegen
+- F-T6-2 FIXED, T5/T6 re-checkpointed
+- Ruling: T8 Consumes cleared (T7 block frozen with take/put names); T8 notes name takeAt/putAt; edge T7->T8 kept - cost if wrong: none
+- unblocked: dispatched T8 (fresh) at 15:17:17; waiting on fixes: none
+- checkpoint T8 968ef98c72 scene modules on own
+- T8 checkpointed 968ef98 (38 tests; clone test removed; 3 leaves_input_unchanged tests replaced by in-place equivalents; Handled/StageHandled/Stage own records)
+- F-T8-1 to fixer-sonnet-high: match pattern bindings untracked (move-out hole)
+- unblocked: dispatched T9 to a7cd687 at 15:20:50; waiting on fixes: F-T8-1
+- tests fast passed=1 failed=0 skipped=0 seconds=37.4
+- checkpoint T5 b8ee44d8b1 ownership checker: branches, loops, closures, fields
+- F-T8-1 FIXED: match on owned scrutinee moves it, pattern names owned; borrowed -> names borrowed; synthesized union forwarders skipped. flow 27/27
+- checkpoint T9 d692c712f3 example and fixture on own
+- T9 checkpointed d692c71. Benchmark phase B: avg 2.107/1.931 p95 2.7/2.3 upd 0.343/0.316 vs mutable 1.736/1.738 p95 1.9 -> MISSED; written docs/plans/2026-11-03-own-record.benchmark.md
+- Rebase onto master 9117837 (inline record variants + = match bodies): phase B committed 6525e4c; conflicts ast.rs parser.rs parser.c -> fixer-sonnet-high. Reverted superlite's .gitignore additions (ignored committed design docs)
+- Ruling: [scope] user approved T14: Picture SceneNode + state/view Msg on inline-variant enums with = match bodies, after the rebase - cost if wrong: one task
+- Rebase DONE onto master 05f8c38 (512 Rust / 593 Plum / 118 corpus green); hidden inline-variant records inherit isOwn
+- Ruling: [scope] T14 recursive Picture + T15 recursive state/view added (user: recursive type + recursive fns; tail calls / supercompiler later, out of scope); children as recursive Nodes = End | More - cost if wrong: deep recursion slower until tail calls
+- unblocked: dispatched T13 T14 (fresh) at 15:32:51; T15 after T14
+- checkpoint T14 e54f685579 recursive Picture
+- T14 checkpointed e54f685 (Picture recursive: inline-variant SceneNode/Transform(+Identity)/Effect, Nodes=End|More; 6/6)
+- unblocked: dispatched T15 to a7ed9fc at 15:35:12
+- checkpoint T13 88103bd15c docs
+- T13 checkpointed 88103bd (README Own records; example uses t := Cell(..s, ...))
+- F-T6-3 to fixer-opus: s = Cell(..s, ...) on own param traps (wasm cast failure), cause unknown
+- tests fast passed=1 failed=0 skipped=0 seconds=57.4
+- checkpoint T15 b689125069 recursive state/view game and fixture
+- checkpoint T6 017bd757c0 in-place spread codegen
+- F-T6-3 FIXED (pre-existing): assigning to any param created a shadow local read for the whole body (Int params silently read 0, records trapped); now reuses the param slot. 594 Plum tests green
+- T15 checkpointed b689125. Recursive state/view headed: avg 1.905/1.908 p95 2.3 p99 2.4 upd 0.05 draw 1.49 vs mutable 1.729 p95 1.9
+- tests full passed=1765 failed=0 skipped=0 seconds=110.6
+- Final review CHANGES_REQUESTED; ruled after direct checks: full suite 1765/0 (run_tests --full --wait).
+- Ruling: finding "codegen red / own_spread_reuses_object" - stale incident [1]; suite green, own_inplace_e2e 12 pass - cost if wrong: none
+- Ruling: finding "Int false positive" - fixed by F-T5-1, regression int_param_alias_not_tracked_with_own_present - cost if wrong: none
+- Ruling: finding "approximate move positions" - real; deferred follow-up (add line/col to Stmt::Assign, Expr::ClassCall) - cost if wrong: error columns approximate (lines correct)
+- Ruling: finding "state not probed" - flow tests cover joins/loops/closures/early return (27 pass) - cost if wrong: none
+- Ruling: finding "Picture fns missing" - tooling cannot parse Plum; Picture.plum:217-227 present, 6 tests - cost if wrong: none
+- Ruling: finding "T7 Produces take/put" - block frozen; rename recorded in T8 notes and rulings - cost if wrong: doc drift only

docs/plans/2026-11-03-own-record.report.json ADDED Viewed

@@ -0,0 +1,342 @@
+{
+ "projection_note": "projection: fixed forecast saved at lint 2026-11-03T14:37:44 (plan edited since)",
+ "headline": {
+  "wall_min": {
+   "projected": 13.605,
+   "actual": 61.825
+  },
+  "cost_usd_agents": {
+   "projected": 1.742609,
+   "actual": 9.027237
+  },
+  "task_min": {
+   "projected": 25.758,
+   "actual": 83.348
+  },
+  "agents": {
+   "projected": 13,
+   "actual": 20
+  }
+ },
+ "feature": null,
+ "cost_split": {
+  "agents_usd": 6.859187,
+  "rework_usd": 2.16805,
+  "coordinator_usd": 25.293098,
+  "total_usd": 34.320335
+ },
+ "concurrency": {
+  "peak": 4,
+  "projected_peak": 4
+ },
+ "critical_path": {
+  "actual": [
+   "T3",
+   "T6"
+  ],
+  "projected": [
+   "T3",
+   "T4",
+   "T5",
+   "T7",
+   "T8",
+   "T9",
+   "T13"
+  ],
+  "projected_min": 13.605
+ },
+ "model_mix": {
+  "sonnet": {
+   "tasks": 10,
+   "cost_usd": 9.027237
+  }
+ },
+ "coordinator_cost_by_model": {
+  "opus": 25.293098
+ },
+ "quality": {
+  "tests": {
+   "passed": 1765,
+   "failed": 0,
+   "skipped": 0,
+   "seconds": 110.6,
+   "mode": "full",
+   "failures": [],
+   "skipped_tests": []
+  },
+  "first_time_pass": 0,
+  "first_time_n": 1,
+  "rework_dispatches": 5,
+  "open_incidents": 38
+ },
+ "tasks": [
+  {
+   "task": "T6",
+   "model": "sonnet",
+   "pred_min": 1.612,
+   "actual_min": 32.548,
+   "delta": {
+    "abs": 30.9363,
+    "pct": 1919.1
+   },
+   "cost_usd": 3.216926,
+   "first_time_pass": false
+  },
+  {
+   "task": "T5",
+   "model": "sonnet",
+   "pred_min": 1.769,
+   "actual_min": 7.252,
+   "delta": {
+    "abs": 5.4827,
+    "pct": 309.9
+   },
+   "cost_usd": 1.200695,
+   "first_time_pass": null
+  },
+  {
+   "task": "T3",
+   "model": "sonnet",
+   "pred_min": 2.094,
+   "actual_min": 7.223,
+   "delta": {
+    "abs": 5.1293,
+    "pct": 245.0
+   },
+   "cost_usd": 0.755352,
+   "first_time_pass": null
+  },
+  {
+   "task": "T8",
+   "model": "sonnet",
+   "pred_min": 2.459,
+   "actual_min": 7.138,
+   "delta": {
+    "abs": 4.6793,
+    "pct": 190.3
+   },
+   "cost_usd": 1.148973,
+   "first_time_pass": null
+  },
+  {
+   "task": "T2",
+   "model": "sonnet",
+   "pred_min": 2.178,
+   "actual_min": 6.643,
+   "delta": {
+    "abs": 4.4653,
+    "pct": 205.0
+   },
+   "cost_usd": 0.290503,
+   "first_time_pass": null
+  },
+  {
+   "task": "T10",
+   "model": "sonnet",
+   "pred_min": 1.691,
+   "actual_min": 5.927,
+   "delta": {
+    "abs": 4.2357,
+    "pct": 250.5
+   },
+   "cost_usd": 0.715954,
+   "first_time_pass": null
+  },
+  {
+   "task": "T4",
+   "model": "sonnet",
+   "pred_min": 1.847,
+   "actual_min": 4.74,
+   "delta": {
+    "abs": 2.893,
+    "pct": 156.6
+   },
+   "cost_usd": 0.393466,
+   "first_time_pass": null
+  },
+  {
+   "task": "T13",
+   "model": "sonnet",
+   "pred_min": 1.4,
+   "actual_min": 2.523,
+   "delta": {
+    "abs": 1.1233,
+    "pct": 80.2
+   },
+   "cost_usd": 0.24823,
+   "first_time_pass": null
+  },
+  {
+   "task": "T1",
+   "model": "sonnet",
+   "pred_min": 1.937,
+   "actual_min": 2.073,
+   "delta": {
+    "abs": 0.1363,
+    "pct": 7.0
+   },
+   "cost_usd": 0.211794,
+   "first_time_pass": null
+  },
+  {
+   "task": "T14",
+   "model": "sonnet",
+   "pred_min": null,
+   "actual_min": 7.28,
+   "delta": {
+    "abs": null,
+    "pct": null
+   },
+   "cost_usd": 0.845344,
+   "first_time_pass": null
+  }
+ ],
+ "cost_table": {
+  "source": "est",
+  "usd": 9.3617,
+  "tokens": 30849464,
+  "wall_min": 119580025.0231,
+  "rows": [
+   {
+    "agent": "a01a9e03e2acb835b",
+    "model": "sonnet",
+    "wall_min": 1.5649,
+    "tokens": 231841,
+    "usd": 0.1368
+   },
+   {
+    "agent": "a0e8dea8f85f13dbf",
+    "model": "sonnet",
+    "wall_min": 9.2805,
+    "tokens": 1529221,
+    "usd": 0.5023
+   },
+   {
+    "agent": "a1f4933624de7b5ef",
+    "model": "sonnet",
+    "wall_min": 6.0213,
+    "tokens": 1085351,
+    "usd": 0.716
+   },
+   {
+    "agent": "a3e35069781629003",
+    "model": "sonnet",
+    "wall_min": 4.4801,
+    "tokens": 1579541,
+    "usd": 0.447
+   },
+   {
+    "agent": "a440ab2702c72dcc7",
+    "model": "sonnet",
+    "wall_min": 3.066,
+    "tokens": 1243873,
+    "usd": 0.3122
+   },
+   {
+    "agent": "a53be28dbfee6f9f8",
+    "model": "sonnet",
+    "wall_min": 32.6157,
+    "tokens": 9405486,
+    "usd": 1.6496
+   },
+   {
+    "agent": "a645d85b6578c5875",
+    "model": "sonnet",
+    "wall_min": 29894955.8928,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a68b5d7f23754c57c",
+    "model": "sonnet",
+    "wall_min": 12.2574,
+    "tokens": 3610245,
+    "usd": 1.012
+   },
+   {
+    "agent": "a7cd68767266f8c93",
+    "model": "sonnet",
+    "wall_min": 7.1753,
+    "tokens": 2932728,
+    "usd": 0.8604
+   },
+   {
+    "agent": "a7ed9fc0c1c782ec6",
+    "model": "sonnet",
+    "wall_min": 7.3337,
+    "tokens": 1950255,
+    "usd": 0.8453
+   },
+   {
+    "agent": "a83ddb1893bfc4ac1",
+    "model": "sonnet",
+    "wall_min": 29894955.9872,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a8aad43f5eeb9f328",
+    "model": "sonnet",
+    "wall_min": 2.6288,
+    "tokens": 733083,
+    "usd": 0.2482
+   },
+   {
+    "agent": "a95910dd785a9fb35",
+    "model": "sonnet",
+    "wall_min": 7.2874,
+    "tokens": 3048672,
+    "usd": 0.8885
+   },
+   {
+    "agent": "a969fabbbf56da79e",
+    "model": "opus",
+    "wall_min": 0.4953,
+    "tokens": 44207,
+    "usd": 0.2016
+   },
+   {
+    "agent": "a9cb67589cc0e1ed2",
+    "model": "sonnet",
+    "wall_min": 3.6224,
+    "tokens": 1278155,
+    "usd": 0.3731
+   },
+   {
+    "agent": "ac171c85cba4b85f2",
+    "model": "opus",
+    "wall_min": 4.4896,
+    "tokens": 1108958,
+    "usd": 0.7473
+   },
+   {
+    "agent": "acd825d12312cafcd",
+    "model": "sonnet",
+    "wall_min": 4.1557,
+    "tokens": 319327,
+    "usd": 0.1328
+   },
+   {
+    "agent": "ad18889d1756b4c8d",
+    "model": "sonnet",
+    "wall_min": 29894997.312,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "ad338bf16e18c83e2",
+    "model": "sonnet",
+    "wall_min": 29895006.0052,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "af3bca1f1f48b0c08",
+    "model": "sonnet",
+    "wall_min": 3.3518,
+    "tokens": 748521,
+    "usd": 0.2886
+   }
+  ]
+ }
+}

docs/plans/2026-11-03-own-record.report.md ADDED Viewed

@@ -0,0 +1,49 @@
+# superlite build report
+projection: fixed forecast saved at lint 2026-11-03T14:37:44 (plan edited since)
+                         Projected    Actual  Delta
+wall-clock (min)              13.6      61.8  +48.2 (+354%)
+agent cost (USD, +rework)      1.74      9.03  +7.28 (+418%)
+task-minutes                  25.8      83.3  +57.6 (+224%)
+agents                          13        20  +7 (+54%)
+cost split: agents $6.86, rework $2.17, coordinator $25.29, total $34.32
+concurrency: peak 4 at once (projected 4); critical path actual T3 T6; projected T3 > T4 > T5 > T7 > T8 > T9 > T13 (13.6 min)
+model mix: sonnet 10 tasks $9.03, coordinator opus $25.29
+quality: tests 1765 passed, 0 failed; first-time pass 0/1 (0%); rework dispatches 5; open incidents 38
+task  model      pred  actual  delta             cost
+T6    sonnet      1.6    32.5  +30.9 (+1919%)  $3.217  first-time miss
+T5    sonnet      1.8     7.3  +5.5 (+310%)    $1.201
+T3    sonnet      2.1     7.2  +5.1 (+245%)    $0.755
+T8    sonnet      2.5     7.1  +4.7 (+190%)    $1.149
+T2    sonnet      2.2     6.6  +4.5 (+205%)    $0.291
+(+5 smaller misses; `superlite-cli report --json` lists all)
+agent cost table:
+| agent | model | wall_min | tokens | usd |
+| --- | --- | --- | --- | --- |
+| a01a9e03e2acb835b | sonnet | 1.5649 | 231841 | 0.1368 |
+| a0e8dea8f85f13dbf | sonnet | 9.2805 | 1529221 | 0.5023 |
+| a1f4933624de7b5ef | sonnet | 6.0213 | 1085351 | 0.716 |
+| a3e35069781629003 | sonnet | 4.4801 | 1579541 | 0.447 |
+| a440ab2702c72dcc7 | sonnet | 3.066 | 1243873 | 0.3122 |
+| a53be28dbfee6f9f8 | sonnet | 32.6157 | 9405486 | 1.6496 |
+| a645d85b6578c5875 | sonnet | 29894955.8928 | 0 | 0.0 |
+| a68b5d7f23754c57c | sonnet | 12.2574 | 3610245 | 1.012 |
+| a7cd68767266f8c93 | sonnet | 7.1753 | 2932728 | 0.8604 |
+| a7ed9fc0c1c782ec6 | sonnet | 7.3337 | 1950255 | 0.8453 |
+| a83ddb1893bfc4ac1 | sonnet | 29894955.9872 | 0 | 0.0 |
+| a8aad43f5eeb9f328 | sonnet | 2.6288 | 733083 | 0.2482 |
+| a95910dd785a9fb35 | sonnet | 7.2874 | 3048672 | 0.8885 |
+| a969fabbbf56da79e | opus | 0.4953 | 44207 | 0.2016 |
+| a9cb67589cc0e1ed2 | sonnet | 3.6224 | 1278155 | 0.3731 |
+| ac171c85cba4b85f2 | opus | 4.4896 | 1108958 | 0.7473 |
+| acd825d12312cafcd | sonnet | 4.1557 | 319327 | 0.1328 |
+| ad18889d1756b4c8d | sonnet | 29894997.312 | 0 | 0.0 |
+| ad338bf16e18c83e2 | sonnet | 29895006.0052 | 0 | 0.0 |
+| af3bca1f1f48b0c08 | sonnet | 3.3518 | 748521 | 0.2886 |
+| totals |  | 119580025.0231 | 30849464 | 9.3617 |
+cost source: est
+takeaway: ran 354% slower than projected; cost 418% over; biggest miss T6

plum-examples/game_state_view.plum CHANGED Viewed

@@ -4,11 +4,13 @@
 # WASD, collect the drifting orbs and avoid the mines. Three lives; Enter, R or the
 # "Again" button restarts after the game is over.
 #
-# The game is three plain pieces. `State` is flat data: the ship, the orbs and the
+# The game is three plain pieces. `State` is plain data: the ship, the orbs and the
-# mines keyed by id, the score, the random seed and the screen size. `Msg` is what
+# mines (recursive `Link` lists keyed by id), the score, the random seed and the screen
-# can happen to it (a tick of time, a resize, a restart). `step(state, msg)` is pure
+# size. `Msg` is what can happen to it (a tick of time, a resize, a restart), an enum
-# and returns the next `State`; `view(state)` is pure too and builds a fresh
+# with inline variants. `step(state, msg)` is pure and returns the next `State`;
-# `SceneNode` picture every frame, which `Picture.draw` interprets. There is no
+# `view(state)` is pure too and builds a fresh `SceneNode` picture every frame, which
+# `Picture.draw` interprets. Both are structural recursion over `Link` and `Nodes`:
+# no loop runs in `step` or `view`. There is no
 # retained scene: the restart button is found by `Picture.hitPath` on the picture
 # the player is looking at. The `World` record is the host shell: it holds the
 # current `State`, reads the keyboard and mouse into messages, and plays sounds.
@@ -70,8 +72,8 @@ struct Mine(id: Int, x: Float, y: Float, vx: Float, vy: Float, rotation: Float,
 # the view needs: the sprite sheet and the render target of the game-over filter.
 record State(
   ship: ShipState,
-  orbs: List[Orb],
+  orbs: Link[Orb],
-  mines: List[Mine],
+  mines: Link[Mine],
   seed: Int,
   score: Int,
   best: Int,
@@ -85,14 +87,41 @@ record State(
   target: Int)
 # What can happen to the state.
+enum Msg =
-struct Tick(dt: Float, ax: Float, ay: Float)
+  | Tick(dt: Float, ax: Float, ay: Float)
-struct Resize(w: Float, h: Float)
+  | Resize(w: Float, h: Float)
-# A new run with `seed`, keeping the best score.
-struct Restart(seed: Int)
+  | Restart(seed: Int)
+# A recursive list: the empty `Nil`, or a head in front of another list.
-enum Msg = Tick | Resize | Restart
+enum Link[T] = Nil | Cons(head: T, tail: Link[T])
+fun mapLink(xs: Link[A], f: fn(A) -> B) -> Link[B] = match xs
+  Nil => Nil
+  Cons(h, t) => Cons(head: f(h), tail: mapLink(t, f))
+fun lenLink(xs: Link[T]) -> Int = match xs
+  Nil => 0
+  Cons(_, t) => 1 + lenLink(t)
+# `xs` with `x` added at the end.
+fun snoc(xs: Link[T], x: T) -> Link[T] = match xs
+  Nil => Cons(head: x, tail: Nil)
+  Cons(h, t) => Cons(head: h, tail: snoc(t, x))
+# `xs` with the element at `i` replaced by `x`.
+fun replaceNth(xs: Link[T], i: Int, x: T) -> Link[T] = match xs
+  Nil => Nil
+  Cons(h, t) => if i <= 0 then Cons(head: x, tail: t) else Cons(head: h, tail: replaceNth(t, i - 1, x))
+# The element at `i`, or `dflt` past the end.
+fun nthOr(xs: Link[T], i: Int, dflt: T) -> T = match xs
+  Nil => dflt
+  Cons(h, t) => if i <= 0 then h else nthOr(t, i - 1, dflt)
+# The nodes f(x) for every x of `xs`, followed by `rest`.
+fun toNodes(xs: Link[T], f: fn(T) -> SceneNode, rest: Nodes) -> Nodes = match xs
+  Nil => rest
+  Cons(h, t) => More(head: f(h), tail: toNodes(t, f, rest))
 # --- small pure helpers ---
@@ -193,88 +222,108 @@ fun mineMove(k: Mine, dt: Float) -> Mine =
 # --- the state ---
+# A built list of orbs and the seed to continue from.
+record OrbsMade(orbs: Link[Orb], seed: Int)
+record MinesMade(mines: Link[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()
-  sd := seed
-  orbs := List[Orb]()
-  for i := range Rules.OrbCount
+  made := makeOrbs(0, seed, ship)
-    sp := spawn(sd, ship.x, ship.y, 120.0, 40.0)
+  mm := makeMines(0, mineCount(0), made.seed, ship)
-    sd = sp.seed
-    orbs.push(orbAt(Id.Orb + i, Float(i) * 0.1, 0.0, Motion(x: sp.x, y: sp.y, vx: sp.vx, vy: sp.vy)))
-  mines := List[Mine]()
-  for i := range mineCount(0)
-    sp := spawn(sd, ship.x, ship.y, 220.0, 90.0)
-    sd = sp.seed
-    mines.push(mineAt(Id.Mine + i, 0.0, 2.0, 0.0, Motion(x: sp.x, y: sp.y, vx: sp.vx, vy: sp.vy)))
   State(
-    ship: ship, orbs: orbs, mines: mines, seed: sd, score: 0, best: best, lives: Rules.StartLives,
+    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, 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)
-  orbs := List[Orb]()
-  for i := range s.orbs.length()
+  n.orbs = mapLink(s.orbs, |o| orbStill(o))
-    o := s.orbs.at(i)
-    orbs.push(orbAt(o.id, o.phase, o.clock, Motion(x: o.x, y: o.y, vx: 0.0, vy: 0.0)))
-  mines := List[Mine]()
-  for i := range s.mines.length()
+  n.mines = mapLink(s.mines, |k| mineStill(k))
-    k := s.mines.at(i)
-    mines.push(mineAt(k.id, k.rotation, 0.0, k.clock, Motion(x: k.x, y: k.y, vx: 0.0, vy: 0.0)))
-  n.orbs = orbs
-  n.mines = mines
   n
+# The orbs after the ship collected the ones it touches, with the score and seed.
+record Collected(orbs: Link[Orb], seed: Int, score: Int)
+fun collectOrbs(orbs: Link[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: Link[Mine], have: Int, want: Int, seed: Int, ship: ShipState) -> MinesMade =
+  if have >= want
+    return MinesMade(mines: mines, seed: seed)
+  sp := spawn(seed, ship.x, ship.y, 220.0, 90.0)
+  added := snoc(mines, mineAt(Id.Mine + have, 0.0, 2.0, 0.0, Motion(x: sp.x, y: sp.y, vx: sp.vx, vy: sp.vy)))
+  growMines(added, have + 1, want, sp.seed, ship)
+fun touchesMine(mines: Link[Mine], ship: ShipState) -> Bool = match mines
+  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
-  orbs := List[Orb]()
-  for i := range s.orbs.length()
-    orbs.push(orbMove(s.orbs.at(i), dt))
+  n.orbs = mapLink(s.orbs, |o| orbMove(o, dt))
-  mines := List[Mine]()
-  for i := range s.mines.length()
-    mines.push(mineMove(s.mines.at(i), dt))
+  n.mines = mapLink(s.mines, |k| mineMove(k, dt))
-  n.orbs = orbs
-  n.mines = mines
   if s.over
     n.overClock = s.overClock + dt
     return n
   ship := shipStep(s.ship, ax, ay, dt)
   n.ship = ship
-  collected := List[Orb]()
-  for i := range orbs.length()
-    o := orbs.at(i)
-    if overlaps(ship.x, ship.y, Rules.ShipRadius, o.x, o.y, Rules.OrbRadius)
-      n.score = n.score + Rules.OrbPoints
-      sp := spawn(n.seed, ship.x, ship.y, 120.0, 40.0)
+  got := collectOrbs(n.orbs, ship, n.seed, n.score)
+  n.orbs = got.orbs
-      n.seed = sp.seed
+  n.seed = got.seed
-      collected.push(orbAt(o.id, o.phase, o.clock, Motion(x: sp.x, y: sp.y, vx: sp.vx, vy: sp.vy)))
-    else
-      collected.push(o)
-  n.orbs = collected
+  n.score = got.score
-  while n.mines.length() < mineCount(n.score)
+  grown := growMines(n.mines, lenLink(n.mines), mineCount(n.score), n.seed, ship)
-    sp := spawn(n.seed, ship.x, ship.y, 220.0, 90.0)
+  n.mines = grown.mines
-    n.seed = sp.seed
+  n.seed = grown.seed
-    n.mines.push(mineAt(Id.Mine + n.mines.length(), 0.0, 2.0, 0.0, Motion(x: sp.x, y: sp.y, vx: sp.vx, vy: sp.vy)))
-  for i := range n.mines.length()
-    k := n.mines.at(i)
-    if n.ship.hurt <= 0.0 && overlaps(ship.x, ship.y, Rules.ShipRadius, k.x, k.y, Rules.MineRadius)
+  if n.ship.hurt <= 0.0 && touchesMine(n.mines, ship)
-      n.lives = n.lives - 1
+    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.ship = ShipState(x: ship.x, y: ship.y, vx: ship.vx, vy: ship.vy, rotation: ship.rotation, hurt: Rules.HurtTime)
-      if n.lives <= 0
+    if n.lives <= 0
-        n.over = true
+      n.over = true
-        n.best = n.best.max(n.score)
+      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 =
+fun step(s: State, msg: Msg) -> State = match msg
-  match msg
-    Tick => tick(s, msg.dt, msg.ax, msg.ay)
+  Tick(dt, ax, ay) => tick(s, dt, ax, ay)
-    Resize => resized(s, msg.w, msg.h)
+  Resize(w, h) => resized(s, w, h)
-    Restart => newState(msg.seed, s.best.max(s.score), s.sheet, s.target, s.sw, s.sh)
+  Restart(seed) => newState(seed, s.best.max(s.score), s.sheet, s.target, s.sw, s.sh)
 fun resized(s: State, w: Float, h: Float) -> State =
   n := State(..s)
@@ -304,86 +353,90 @@ fun starView(i: Int, clock: Float) -> SceneNode =
   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) -> Nodes =
+  if i >= 40 then End else More(head: starView(i, clock), tail: starNodes(i + 1, clock))
 fun starsView(clock: Float) -> SceneNode =
-  kids := List[SceneNode]()
-  for i := range 40
-    kids.push(starView(i, clock))
-  Group(transform: List[Transform](), children: kids)
+  Group(transform: Identity, children: starNodes(0, clock))
 fun mineView(sheet: Int, k: Mine) -> SceneNode =
   Group(
-    transform: List(Translate(dx: k.x, dy: k.y), Rotate(radians: k.rotation)),
+    transform: Compose(first: Translate(dx: k.x, dy: k.y), then: Rotate(radians: k.rotation)),
-    children: List(cell(sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(k.clock, 4, 4.0), 2)))
+    children: More(head: cell(sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(k.clock, 4, 4.0), 2), tail: End))
 # The glow is drawn additively, then the sprite on top.
 fun orbView(sheet: Int, o: Orb) -> SceneNode =
   glow := Group(
-    transform: List[Transform](),
+    transform: Identity,
-    children: List(
+    children: More(
-      CircleShape(cx: 0.0, cy: 0.0, r: 26.0, color: Color(r: 0.35, g: 0.22, b: 0.0, a: 0.5)),
+      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)),
-      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: More(head: CircleShape(cx: 0.0, cy: 0.0, r: 17.0, color: Color(r: 0.6, g: 0.4, b: 0.05, a: 0.5)), tail: End)))
   Group(
-    transform: List(Translate(dx: o.x, dy: o.y)),
+    transform: Translate(dx: o.x, dy: o.y),
-    children: List(
+    children: More(
-      Filter(effect: BlendFx(mode: Blend.Add), child: glow, target: 0 - 1),
+      head: Filter(effect: BlendFx(mode: Blend.Add), child: glow, target: 0 - 1),
-      cell(sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(o.clock + o.phase, 4, 8.0), 1)))
+      tail: More(head: cell(sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(o.clock + o.phase, 4, 8.0), 1), tail: End)))
 # The ship blinks while hurt and is gone once the game is over (an empty group keeps the slots).
 fun shipView(s: State) -> SceneNode =
   blink := s.ship.hurt > 0.0 && frameOf(s.clock, 2, 10.0) == 0
   if s.over || blink
-    return Group(transform: List[Transform](), children: List[SceneNode]())
+    return Group(transform: Identity, children: End)
   Group(
-    transform: List(Translate(dx: s.ship.x, dy: s.ship.y), Rotate(radians: s.ship.rotation)),
+    transform: Compose(first: Translate(dx: s.ship.x, dy: s.ship.y), then: Rotate(radians: s.ship.rotation)),
-    children: List(
+    children: More(
-      CircleShape(cx: 0.0, cy: 0.0, r: 17.0, color: Color(r: 0.4, g: 0.8, b: 1.0, a: 0.12)),
+      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)),
-      cell(s.sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(s.clock, 4, 14.0), 0)))
+      tail: More(head: cell(s.sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(s.clock, 4, 14.0), 0), tail: End)))
+# One life icon per remaining life, from the right edge going left.
+fun lifeNodes(i: Int, lives: Int, sheet: Int) -> Nodes =
+  if i >= lives
+    End
+  else
+    More(head: cell(sheet, Rules.ArenaW - 40.0 - Float(i) * 36.0, 12.0, 32.0, 0, 0), tail: lifeNodes(i + 1, lives, sheet))
 fun hudView(s: State) -> SceneNode =
+  Group(
+    transform: Identity,
-  kids := List[SceneNode]()
+    children: More(
-  kids.push(Text(text: "Score {s.score}", x: 16.0, y: 12.0, size: 28.0, color: Color.White))
+      head: Text(text: "Score {s.score}", x: 16.0, y: 12.0, size: 28.0, color: Color.White),
-  kids.push(Text(text: "Best {s.best.max(s.score)}", x: 16.0, y: 44.0, size: 20.0, color: Color.Yellow))
+      tail: More(head: Text(text: "Best {s.best.max(s.score)}", x: 16.0, y: 44.0, size: 20.0, color: Color.Yellow), tail: lifeNodes(0, s.lives, s.sheet))))
-  for i := range s.lives
-    kids.push(cell(s.sheet, Rules.ArenaW - 40.0 - Float(i) * 36.0, 12.0, 32.0, 0, 0))
-  Group(transform: List[Transform](), children: kids)
 # 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: List[Transform](), children: List[SceneNode]())
+    return Group(transform: Identity, children: End)
   button := Group(
-    transform: List[Transform](),
+    transform: Identity,
-    children: List(
+    children: More(
-      RectShape(x: 340.0, y: 342.0, w: 120.0, h: 44.0, color: Color(r: 0.5, g: 0.8, b: 1.0, a: 0.9)),
+      head: RectShape(x: 340.0, y: 342.0, w: 120.0, h: 44.0, color: Color(r: 0.5, g: 0.8, b: 1.0, a: 0.9)),
-      Text(text: "Again", x: 372.0, y: 352.0, size: 24.0, color: Color.White)))
+      tail: More(head: Text(text: "Again", x: 372.0, y: 352.0, size: 24.0, color: Color.White), tail: End)))
   panel := Group(
-    transform: List[Transform](),
+    transform: Identity,
-    children: List(
+    children: More(
-      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)),
+      head: RectShape(x: 0.0, y: 230.0, w: Rules.ArenaW, h: 170.0, color: Color(r: 0.0, g: 0.0, b: 0.0, a: 0.6)),
+      tail: More(
-      Text(text: "Game over", x: 300.0, y: 244.0, size: 48.0, color: Color.Red),
+        head: Text(text: "Game over", x: 300.0, y: 244.0, size: 48.0, color: Color.Red),
+        tail: More(
-      Text(text: "Press Enter to play again", x: 270.0, y: 300.0, size: 24.0, color: Color.White),
+          head: Text(text: "Press Enter to play again", x: 270.0, y: 300.0, size: 24.0, color: Color.White),
-      button))
+          tail: More(head: button, tail: End)))))
   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 =
-  mines := List[SceneNode]()
-  for i := range s.mines.length()
-    mines.push(mineView(s.sheet, s.mines.at(i)))
-  orbs := List[SceneNode]()
-  for i := range s.orbs.length()
-    orbs.push(orbView(s.sheet, s.orbs.at(i)))
-  layers := List[SceneNode]()
-  layers.push(RectShape(x: 0.0, y: 0.0, w: Rules.ArenaW, h: Rules.ArenaH, color: Color.rgb(0.07, 0.08, 0.16)))
-  layers.push(starsView(s.clock))
-  layers.push(Group(transform: List[Transform](), children: mines))
-  layers.push(Group(transform: List[Transform](), children: orbs))
-  layers.push(shipView(s))
-  layers.push(hudView(s))
-  layers.push(overlayView(s))
   z := zoomOf(s)
+  layers := More(
+    head: RectShape(x: 0.0, y: 0.0, w: Rules.ArenaW, h: Rules.ArenaH, color: Color.rgb(0.07, 0.08, 0.16)),
+    tail: More(
+      head: starsView(s.clock),
+      tail: More(
+        head: Group(transform: Identity, children: toNodes(s.mines, |k| mineView(s.sheet, k), End)),
+        tail: More(
+          head: Group(transform: Identity, children: toNodes(s.orbs, |o| orbView(s.sheet, o), End)),
+          tail: More(head: shipView(s), tail: More(head: hudView(s), tail: More(head: overlayView(s), tail: End)))))))
-  Group(transform: List(Translate(dx: offsetX(s), dy: offsetY(s)), Scale(sx: z, sy: z)), children: layers)
+  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 =
@@ -461,24 +514,12 @@ fun away() -> Motion =
 fun withOrb(s: State, i: Int, m: Motion) -> State =
   n := State(..s)
-  orbs := List[Orb]()
-  for j := range s.orbs.length()
-    if j == i
-      orbs.push(orbAt(Id.Orb + i, Float(i) * 0.1, 0.0, m))
+  n.orbs = replaceNth(s.orbs, i, orbAt(Id.Orb + i, Float(i) * 0.1, 0.0, m))
-    else
-      orbs.push(s.orbs.at(j))
-  n.orbs = orbs
   n
 fun withMine(s: State, i: Int, m: Motion) -> State =
   n := State(..s)
-  mines := List[Mine]()
-  for j := range s.mines.length()
-    if j == i
-      mines.push(mineAt(Id.Mine + i, 0.0, 2.0, 0.0, m))
+  n.mines = replaceNth(s.mines, i, mineAt(Id.Mine + i, 0.0, 2.0, 0.0, m))
-    else
-      mines.push(s.mines.at(j))
-  n.mines = mines
   n
 # A state with the orbs and mines moved out of the way.
@@ -486,10 +527,16 @@ 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 s.mines.length()
+  for i := range lenLink(s.mines)
     s = withMine(s, i, away())
   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()))
 fun onShip(s: State) -> Motion =
   Motion(x: s.ship.x, y: s.ship.y, vx: 0.0, vy: 0.0)
@@ -500,15 +547,14 @@ fun forceOver(s: State) -> State =
   n.best = s.best.max(s.score)
   n
-fun countNodes(n: SceneNode) -> Int =
+fun countNodes(n: SceneNode) -> Int = match n
-  match n
-    Group =>
-      total := 1
-      for i := range n.children.length()
-        total = total + countNodes(n.children.at(i))
+  Group(_, kids) => 1 + countKids(kids)
-      total
-    Filter => 1 + countNodes(n.child)
+  Filter(_, child, _) => 1 + countNodes(child)
-    _ => 1
+  _ => 1
+fun countKids(ks: Nodes) -> Int = match ks
+  End => 0
+  More(h, t) => countNodes(h) + countKids(t)
 test "steering accelerates and drag slows the ship"
   s := shipStep(newShip(), 1.0, 0.0, 0.1)
@@ -551,11 +597,11 @@ test "a mine spins as it drifts"
 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 := t.orbs.at(0)
+  orb := orbN(t, 0)
   assert t.score == Rules.OrbPoints
   assert Math.hypot(orb.x - t.ship.x, orb.y - t.ship.y) >= 120.0
   assert orb.x < 5000.0
-  assert t.orbs.length() == Rules.OrbCount
+  assert lenLink(t.orbs) == Rules.OrbCount
 test "a mine costs one life and makes the ship flash"
   e := emptyState()
@@ -604,15 +650,15 @@ test "after game over nothing moves but the animations keep running"
   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 := t.mines.at(0)
+  mine := mineN(t, 0)
   for i := range 10
     t = tickOf(t, 1.0, 0.0, 0.1)
-  after := t.mines.at(0)
+  after := mineN(t, 0)
   assert after.x == mine.x
   assert after.rotation == mine.rotation
   assert t.ship.x == Rules.ArenaW / 2.0
   assert after.clock > mine.clock + 0.9
-  assert t.orbs.at(0).clock > 0.9
+  assert orbN(t, 0).clock > 0.9
   assert t.clock > 0.9
   assert t.score == 0
@@ -627,7 +673,7 @@ test "restart resets the run and keeps the best score"
   assert r.best == 90
   assert r.lives == Rules.StartLives
   assert r.ship.x == Rules.ArenaW / 2.0
-  assert r.mines.length() == mineCount(0)
+  assert lenLink(r.mines) == mineCount(0)
   assert countNodes(shipView(r)) == 3
   assert countNodes(overlayView(r)) == 1
@@ -639,9 +685,9 @@ test "more mines appear as the score grows and restart removes them"
   s := State(..e)
   s.score = 100
   t := tickOf(s, 0.0, 0.0, 0.016)
-  assert t.mines.length() == 5
+  assert lenLink(t.mines) == 5
   r := step(t, Restart(seed: 3))
-  assert r.mines.length() == 3
+  assert lenLink(r.mines) == 3
 test "the same seed plays out the same way"
   a := newState(11, 0, -1, -1, Rules.ArenaW, Rules.ArenaH)
@@ -651,9 +697,9 @@ test "the same seed plays out the same way"
     b = tickOf(b, 1.0, -1.0, 0.016)
   assert a.ship.x == b.ship.x
   assert a.score == b.score
-  assert a.mines.at(0).x == b.mines.at(0).x
+  assert mineN(a, 0).x == mineN(b, 0).x
   other := newState(12, 0, -1, -1, Rules.ArenaW, Rules.ArenaH)
-  assert other.orbs.at(0).x != a.orbs.at(0).x
+  assert orbN(other, 0).x != orbN(a, 0).x
 test "fit centres the arena on the screen"
   s := step(emptyState(), Resize(w: 1600.0, h: 600.0))
@@ -697,14 +743,14 @@ 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 := t.orbs.at(0).clock
+  orbClock := orbN(t, 0).clock
-  mineClock := t.mines.at(0).clock
+  mineClock := mineN(t, 0).clock
   assert orbClock > 0.4
   t.lives = 1
   t = tickOf(withMine(t, 1, onShip(t)), 0.0, 0.0, 0.1)
   assert t.over
-  assert t.orbs.at(0).clock > orbClock
+  assert orbN(t, 0).clock > orbClock
-  assert t.mines.at(0).clock > mineClock
+  assert mineN(t, 0).clock > mineClock
 test "view_is_pure"
   s := emptyState()

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

@@ -1,9 +1,11 @@
-# The stress scene of stress_pure_scene.plum written as state and view: 5000 sprites in
+# The stress scene of stress_pure_scene.plum written as state and view, now recursive:
-# 50 slowly rotating groups, 500 rects and 200 circles (sprites of a 1x1 white texture),
+# 5000 sprites in 50 slowly rotating groups, 500 rects and 200 circles (sprites of a
-# 50 texts with a changing number, drawn through a 0.8 camera. `State` is flat structs in
+# 1x1 white texture), 50 texts with a changing number, drawn through a 0.8 camera.
+# `State` is recursive `Link` lists (each spinner owns the `Link` of its 100 dancers);
-# lists (keyed by position, which is the id order); `step` is pure and returns the next
+# `step` is pure, a structural recursion that returns the next state; `view` is pure
-# state; `view` is pure and rebuilds the whole SceneNode tree every frame, which
+# and rebuilds the whole SceneNode tree every frame with recursive functions, which
-# `Picture.draw` interprets. Nothing is retained between frames but `State`.
+# `Picture.draw` interprets. Nothing is retained between frames but `State`. The
+# deepest recursion is the 700 drifters; no loops run in step or view.
 module stress_state_view
 import std/Str
 import std/Int
@@ -23,21 +25,47 @@ primitive Counts =
   WorldW = 1600
   WorldH = 900
+enum Link[T] = Nil | Cons(head: T, tail: Link[T])
+fun mapLink(xs: Link[A], f: fn(A) -> B) -> Link[B] = match xs
+  Nil => Nil
-# A rotating group of dancers: top-left (x, y), pivot (75, 85).
+  Cons(h, t) => Cons(head: f(h), tail: mapLink(t, f))
+# The list f(i), f(i + 1) ... f(n - 1).
-struct Spinner(id: Int, x: Float, y: Float, rotation: Float)
+fun rangeLink(i: Int, n: Int, f: fn(Int) -> T) -> Link[T] =
+  if i >= n then Nil else Cons(head: f(i), tail: rangeLink(i + 1, n, f))
+fun appendLink(xs: Link[T], ys: Link[T]) -> Link[T] = match xs
+  Nil => ys
+  Cons(h, t) => Cons(head: h, tail: appendLink(t, ys))
+# The element at `i`, or `dflt` past the end.
+fun nthOr(xs: Link[T], i: Int, dflt: T) -> T = match xs
+  Nil => dflt
+  Cons(h, t) => if i <= 0 then h else nthOr(t, i - 1, dflt)
+# The nodes f(x) for every x of `xs`, followed by `rest`.
+fun toNodes(xs: Link[T], f: fn(T) -> SceneNode, rest: Nodes) -> Nodes = match xs
+  Nil => rest
+  Cons(h, t) => More(head: f(h), tail: toNodes(t, f, rest))
+fun countNodes(ns: Nodes) -> Int = match ns
+  End => 0
+  More(_, t) => 1 + countNodes(t)
 # A sprite of the sheet inside its group, spinning about its centre.
 struct Dancer(id: Int, x: Float, y: Float, rotation: Float, srcX: Float)
+# A rotating group of dancers: top-left (x, y), pivot (75, 85).
+record Spinner(id: Int, x: Float, y: Float, rotation: Float, dancers: Link[Dancer])
 # A square of the white texture that moves by (dx, dy) per frame and wraps.
 struct Drifter(id: Int, x: Float, y: Float, w: Float, h: Float, dx: Float, dy: Float, color: Color)
 # Shows "n <count>" and counts up each frame.
 struct Counter(id: Int, x: Float, y: Float, n: Int)
-record State(
-  sheet: Int, white: Int,
-  spinners: List[Spinner], dancers: List[Dancer], drifters: List[Drifter], counters: List[Counter])
+record State(sheet: Int, white: Int, spinners: Link[Spinner], drifters: Link[Drifter], counters: Link[Counter])
 fun hue(i: Int) -> Color =
   Color(r: Float(i % 7) / 7.0, g: Float(i % 5) / 5.0, b: 0.4 + Float(i % 3) / 5.0, a: 0.8)
@@ -45,26 +73,20 @@ fun hue(i: Int) -> Color =
 fun newDrifter(id: Int, c: Color, x: Float, y: Float, w: Float, h: Float, dx: Float, dy: Float) -> Drifter =
   Drifter(id: id, x: x, y: y, w: w, h: h, dx: dx, dy: dy, color: c)
+fun newDancer(gi: Int, j: Int) -> Dancer =
+  i := gi * {Counts.Sprites / Counts.Groups} + j
+  Dancer(id: 1000 + i, x: Float({j * j * 13 + j * 37} % 150), y: Float({j * j * 29 + j * 53} % 170), rotation: Float(i), srcX: Float(i % 4 * 16))
+fun newSpinner(gi: Int) -> Spinner =
+  Spinner(id: 100 + gi, x: Float(gi % 10 * 160), y: Float(gi / 10 * 180), rotation: 0.0, dancers: rangeLink(0, Counts.Sprites / Counts.Groups, |j| newDancer(gi, j)))
 fun newState(sheet: Int, white: Int) -> State =
-  per := Counts.Sprites / Counts.Groups
-  spinners := List[Spinner]()
-  dancers := List[Dancer]()
-  for gi := range Counts.Groups
-    spinners.push(Spinner(id: 100 + gi, x: Float(gi % 10 * 160), y: Float(gi / 10 * 180), rotation: 0.0))
-    for j := range per
-      i := gi * per + j
-      dancers.push(Dancer(
-        id: 1000 + i, x: Float({j * j * 13 + j * 37} % 150), y: Float({j * j * 29 + j * 53} % 170),
-        rotation: Float(i), srcX: Float(i % 4 * 16)))
-  drifters := List[Drifter]()
-  for i := range Counts.Rects
-    drifters.push(newDrifter(10000 + i, hue(i), Float(i * 61 % Counts.WorldW), Float(i * 29 % Counts.WorldH), 12.0, 8.0, 2.0, 0.0))
+  rects := rangeLink(0, Counts.Rects, |i| newDrifter(10000 + i, hue(i), Float(i * 61 % Counts.WorldW), Float(i * 29 % Counts.WorldH), 12.0, 8.0, 2.0, 0.0))
-  for i := range Counts.Circles
-    drifters.push(newDrifter(20000 + i, hue(i + 3), Float(i * 83 % Counts.WorldW), Float(i * 47 % Counts.WorldH), 12.0, 12.0, 3.0, 1.0))
+  circles := rangeLink(0, Counts.Circles, |i| newDrifter(20000 + i, hue(i + 3), Float(i * 83 % Counts.WorldW), Float(i * 47 % Counts.WorldH), 12.0, 12.0, 3.0, 1.0))
+  State(
+    sheet: sheet, white: white, spinners: rangeLink(0, Counts.Groups, |gi| newSpinner(gi)),
-  counters := List[Counter]()
+    drifters: appendLink(rects, circles),
-  for i := range Counts.Texts
-    counters.push(Counter(id: 30000 + i, x: Float(i * 30 % Counts.WorldW), y: Float(i * 17 % Counts.WorldH), n: i))
+    counters: rangeLink(0, Counts.Texts, |i| Counter(id: 30000 + i, x: Float(i * 30 % Counts.WorldW), y: Float(i * 17 % Counts.WorldH), n: i)))
-  State(sheet: sheet, white: white, spinners: spinners, dancers: dancers, drifters: drifters, counters: counters)
 # --- step: pure ---
@@ -77,56 +99,46 @@ fun stepDrifter(d: Drifter) -> Drifter =
     ny = ny - Float(Counts.WorldH)
   Drifter(id: d.id, x: nx, y: ny, w: d.w, h: d.h, dx: d.dx, dy: d.dy, color: d.color)
+fun stepDancer(d: Dancer, dt: Float) -> Dancer =
+  Dancer(id: d.id, x: d.x, y: d.y, rotation: d.rotation + 1.2 * dt, srcX: d.srcX)
+fun stepSpinner(p: Spinner, dt: Float) -> Spinner =
+  Spinner(id: p.id, x: p.x, y: p.y, rotation: p.rotation + 0.24 * dt, dancers: mapLink(p.dancers, |d| stepDancer(d, dt)))
+fun stepCounter(c: Counter) -> Counter =
+  Counter(id: c.id, x: c.x, y: c.y, n: c.n + 1)
 fun step(s: State, dt: Float) -> State =
-  spinners := List[Spinner]()
-  for i := range s.spinners.length()
-    p := s.spinners.at(i)
-    spinners.push(Spinner(id: p.id, x: p.x, y: p.y, rotation: p.rotation + 0.24 * dt))
-  dancers := List[Dancer]()
-  for i := range s.dancers.length()
-    d := s.dancers.at(i)
+  State(
-    dancers.push(Dancer(id: d.id, x: d.x, y: d.y, rotation: d.rotation + 1.2 * dt, srcX: d.srcX))
-  drifters := List[Drifter]()
-  for i := range s.drifters.length()
-    drifters.push(stepDrifter(s.drifters.at(i)))
-  counters := List[Counter]()
-  for i := range s.counters.length()
-    c := s.counters.at(i)
-    counters.push(Counter(id: c.id, x: c.x, y: c.y, n: c.n + 1))
-  State(sheet: s.sheet, white: s.white, spinners: spinners, dancers: dancers, drifters: drifters, counters: counters)
+    sheet: s.sheet, white: s.white, spinners: mapLink(s.spinners, |p| stepSpinner(p, dt)),
+    drifters: mapLink(s.drifters, |d| stepDrifter(d)), counters: mapLink(s.counters, |c| stepCounter(c)))
 # --- view: pure, the whole tree every frame ---
 fun dancerView(sheet: Int, d: Dancer) -> SceneNode =
   Group(
-    transform: List(Translate(dx: d.x + 8.0, dy: d.y + 8.0), Rotate(radians: d.rotation), Translate(dx: 0.0 - 8.0, dy: 0.0 - 8.0)),
+    transform: Compose(first: Translate(dx: d.x + 8.0, dy: d.y + 8.0), then: Compose(first: Rotate(radians: d.rotation), then: Translate(dx: 0.0 - 8.0, dy: 0.0 - 8.0))),
-    children: List(Sprite(
+    children: More(head: Sprite(
       tex: sheet, x: 0.0, y: 0.0, w: 16.0, h: 16.0, srcX: d.srcX, srcY: 0.0, srcW: 16.0, srcH: 16.0,
-      tint: Color.White)))
+      tint: Color.White), tail: End))
-fun spinnerView(s: State, gi: Int) -> SceneNode =
+fun spinnerView(sheet: Int, p: Spinner) -> SceneNode =
-  per := Counts.Sprites / Counts.Groups
-  p := s.spinners.at(gi)
-  kids := List[SceneNode]()
-  for j := range per
-    kids.push(dancerView(s.sheet, s.dancers.at(gi * per + j)))
   Group(
-    transform: List(Translate(dx: p.x + 75.0, dy: p.y + 85.0), Rotate(radians: p.rotation), Translate(dx: 0.0 - 75.0, dy: 0.0 - 85.0)),
+    transform: Compose(first: Translate(dx: p.x + 75.0, dy: p.y + 85.0), then: Compose(first: Rotate(radians: p.rotation), then: Translate(dx: 0.0 - 75.0, dy: 0.0 - 85.0))),
+    children: toNodes(p.dancers, |d| dancerView(sheet, d), End))
+fun drifterView(white: Int, d: Drifter) -> SceneNode =
+  Sprite(
+    tex: white, x: d.x, y: d.y, w: d.w, h: d.h, srcX: 0.0, srcY: 0.0, srcW: 0.0, srcH: 0.0,
-    children: kids)
+    tint: d.color)
+fun counterView(c: Counter) -> SceneNode =
+  Text(text: "n {c.n}", x: c.x, y: c.y, size: 14.0, color: Color.White)
 fun view(s: State) -> SceneNode =
-  kids := List[SceneNode]()
-  for gi := range Counts.Groups
-    kids.push(spinnerView(s, gi))
-  for i := range s.drifters.length()
-    d := s.drifters.at(i)
-    kids.push(Sprite(
-      tex: s.white, x: d.x, y: d.y, w: d.w, h: d.h, srcX: 0.0, srcY: 0.0, srcW: 0.0, srcH: 0.0,
-      tint: d.color))
-  for i := range s.counters.length()
+  texts := toNodes(s.counters, |c| counterView(c), End)
-    c := s.counters.at(i)
-    kids.push(Text(text: "n {c.n}", x: c.x, y: c.y, size: 14.0, color: Color.White))
+  drifts := toNodes(s.drifters, |d| drifterView(s.white, d), texts)
-  Group(transform: List(Scale(sx: 0.8, sy: 0.8)), children: kids)
+  Group(transform: Scale(sx: 0.8, sy: 0.8), children: toNodes(s.spinners, |p| spinnerView(s.sheet, p), drifts))
 fun whiteTexture() -> Int =
   t := textureCreate(1, 1)
@@ -151,15 +163,16 @@ test "ten frames of step run"
   s := newState(0, 0)
   for i := range 10
     s = step(s, 0.016)
-  assert s.counters.at(3).n == 13
+  assert nthOr(s.counters, 3, Counter(id: 0, x: 0.0, y: 0.0, n: 0)).n == 13
-  assert {s.drifters.at(0).x - 20.0}.abs() < 0.000001
+  assert {nthOr(s.drifters, 0, newDrifter(0, Color.White, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)).x - 20.0}.abs() < 0.000001
+  first := nthOr(s.spinners, 0, newSpinner(0))
-  assert {s.dancers.at(0).rotation - 0.192}.abs() < 0.000001
+  assert {nthOr(first.dancers, 0, newDancer(0, 0)).rotation - 0.192}.abs() < 0.000001
 test "view has one node per actor"
   s := newState(0, 0)
   v := view(s)
   match v
-    Group =>
+    Group(_, kids) =>
-      assert v.children.length() == 50 + 500 + 200 + 50
+      assert countNodes(kids) == 50 + 500 + 200 + 50
     _ =>
       assert false

plum-std/game/Picture.plum CHANGED Viewed

@@ -9,63 +9,51 @@ import std/game/Color
 import std/game/Affine
 import std/game/Game
-# An ML-style picture: a SceneNode is plain data (shapes, sprites, text, groups
+# A recursive picture: a SceneNode is plain data (shapes, sprites, text, groups
-# with transforms, filters) and `Picture` is the interpreter that draws it with a
+# with a transform, filters) and `Picture` is a set of structurally recursive
+# functions that draw it, measure it and hit-test it. Children are a recursive
+# `Nodes` list, so every operation recurses over SceneNode and Nodes, passing
-# matrix stack, measures it and hit-tests it. Nothing here mutates the picture.
+# the parent matrix and alpha down as arguments. Nothing here mutates the picture.
-# Transforms in a group's list compose in order: [Translate, Scale] scales first,
-# then translates (the first entry is the outermost).
+# `Compose(first, then)` applies `then` first, then `first` (`first` is the outermost).
+enum Transform =
+  | Identity
-struct Translate(dx: Float, dy: Float)
+  | Translate(dx: Float, dy: Float)
-struct Rotate(radians: Float)
+  | Rotate(radians: Float)
-struct Scale(sx: Float, sy: Float)
+  | Scale(sx: Float, sy: Float)
-enum Transform = Translate | Rotate | Scale
+  | Compose(first: Transform, then: Transform)
-struct RectShape(x: Float, y: Float, w: Float, h: Float, color: Color)
-struct CircleShape(cx: Float, cy: Float, r: Float, color: Color)
-struct LineShape(x1: Float, y1: Float, x2: Float, y2: Float, thickness: Float, color: Color)
-# A texture region `w` by `h` with its top-left at (x, y).
-struct Sprite(tex: Int, x: Float, y: Float, w: Float, h: Float, srcX: Float, srcY: Float, srcW: Float, srcH: Float, tint: Color)
-record Text(text: Str, x: Float, y: Float, size: Float, color: Color)
-struct Tint(color: Color)
-struct Alpha(alpha: Float)
 # `mode` is a `Blend` constant from std/game/Game.
+enum Effect =
+  | Tint(color: Color)
+  | Alpha(alpha: Float)
-struct BlendFx(mode: Int)
+  | BlendFx(mode: Int)
-enum Effect = Tint | Alpha | BlendFx
-record Group(transform: List[Transform], children: List[SceneNode])
+# A Sprite is a texture region `w` by `h` with its top-left at (x, y).
-# The child is drawn into `target`, then composited with the effect. `target` is a
+# A Filter draws its child into `target`, then composites it with the effect.
-# texture the game creates ONCE at load with `textureCreate`; draw creates nothing,
+# `target` is a texture the game creates ONCE at load with `textureCreate`; draw
-# so a view does not leak a texture per frame. The size of `target` bounds what the
+# creates nothing, so a view does not leak a texture per frame. The size of
-# filter can show: child pixels beyond it are cut off. A negative target draws nothing.
+# `target` bounds what the filter can show: child pixels beyond it are cut off.
+# A negative target draws nothing.
+enum SceneNode =
+  | Group(transform: Transform, children: Nodes)
-record Filter(effect: Effect, child: SceneNode, target: Int)
+  | Filter(effect: Effect, child: SceneNode, target: Int)
+  | Sprite(tex: Int, x: Float, y: Float, w: Float, h: Float, srcX: Float, srcY: Float, srcW: Float, srcH: Float, tint: Color)
+  | Text(text: Str, x: Float, y: Float, size: Float, color: Color)
-enum SceneNode = RectShape | CircleShape | LineShape | Sprite | Text | Group | Filter
+  | RectShape(x: Float, y: Float, w: Float, h: Float, color: Color)
+  | CircleShape(cx: Float, cy: Float, r: Float, color: Color)
+  | LineShape(x1: Float, y1: Float, x2: Float, y2: Float, thickness: Float, color: Color)
+enum Nodes = End | More(head: SceneNode, tail: Nodes)
 struct Rect(x: Float, y: Float, w: Float, h: Float)
-fun picMatrixOf(t: Transform) -> Affine =
+fun picMatrix(t: Transform) -> Affine = match t
-  match t
+  Identity => Affine.Identity
-    Translate => Affine(a: 1.0, b: 0.0, c: 0.0, d: 1.0, e: t.dx, f: t.dy)
+  Translate(dx, dy) => Affine(a: 1.0, b: 0.0, c: 0.0, d: 1.0, e: dx, f: dy)
-    Rotate => Affine(a: Math.cos(t.radians), b: Math.sin(t.radians), c: 0.0 - Math.sin(t.radians), d: Math.cos(t.radians), e: 0.0, f: 0.0)
+  Rotate(rad) => Affine(a: Math.cos(rad), b: Math.sin(rad), c: 0.0 - Math.sin(rad), d: Math.cos(rad), e: 0.0, f: 0.0)
-    Scale => Affine(a: t.sx, b: 0.0, c: 0.0, d: t.sy, e: 0.0, f: 0.0)
+  Scale(sx, sy) => Affine(a: sx, b: 0.0, c: 0.0, d: sy, e: 0.0, f: 0.0)
-fun picCompose(m: Affine, ts: List[Transform]) -> Affine =
+  Compose(first, then) => picMatrix(first).mul(picMatrix(then))
-  out := m
-  for i := range ts.length()
-    out = out.mul(picMatrixOf(ts.at(i)))
-  out
 # The bounding box, in the outer space, of the box (x, y, w, h) seen through `m`.
 fun picBox(x: Float, y: Float, w: Float, h: Float, m: Affine) -> Rect =
@@ -88,138 +76,144 @@ fun picUnion(a: Rect?, b: Rect) -> Rect =
     return Rect(x: x0, y: y0, w: x1 - x0, h: y1 - y0)
   b
+fun picBoxLine(x1: Float, y1: Float, x2: Float, y2: Float, thickness: Float, m: Affine) -> Rect =
+  lx := x1.min(x2) - thickness / 2.0
+  ly := y1.min(y2) - thickness / 2.0
+  picBox(lx, ly, {x1 - x2}.abs() + thickness, {y1 - y2}.abs() + thickness, m)
 # The bounds of `node` drawn under `m`, or null when it has no extent.
-fun picBounds(node: SceneNode, m: Affine) -> Rect? =
+fun picBounds(node: SceneNode, m: Affine) -> Rect? = match node
-  match node
-    RectShape => picBox(node.x, node.y, node.w, node.h, m)
+  RectShape(x, y, w, h, _) => picBox(x, y, w, h, m)
-    CircleShape => picBox(node.cx - node.r, node.cy - node.r, node.r * 2.0, node.r * 2.0, m)
+  CircleShape(cx, cy, r, _) => picBox(cx - r, cy - r, r * 2.0, r * 2.0, m)
-    LineShape =>
-      lx := node.x1.min(node.x2) - node.thickness / 2.0
-      ly := node.y1.min(node.y2) - node.thickness / 2.0
-      picBox(lx, ly, {node.x1 - node.x2}.abs() + node.thickness, {node.y1 - node.y2}.abs() + node.thickness, m)
-    Sprite => picBox(node.x, node.y, node.w, node.h, m)
+  LineShape(x1, y1, x2, y2, th, _) => picBoxLine(x1, y1, x2, y2, th, m)
+  Sprite(_, sx, sy, sw, sh, _, _, _, _, _) => picBox(sx, sy, sw, sh, m)
-    Text => picBox(node.x, node.y, node.size * 0.6 * Float(node.text.length()), node.size, m)
+  Text(txt, tx, ty, size, _) => picBox(tx, ty, size * 0.6 * Float(txt.length()), size, m)
-    Group =>
-      gm := picCompose(m, node.transform)
-      acc: Rect? := null
-      for i := range node.children.length()
-        cb := picBounds(node.children.at(i), gm)
+  Group(tr, kids) => picBoundsKids(kids, m.mul(picMatrix(tr)), null)
-        if cr := cb
-          acc = picUnion(acc, cr)
-      acc
-    Filter => picBounds(node.child, m)
+  Filter(_, child, _) => picBounds(child, m)
+fun picBoundsKids(kids: Nodes, m: Affine, acc: Rect?) -> Rect? = match kids
+  End => acc
+  More(head, tail) =>
+    if cr := picBounds(head, m)
+      picBoundsKids(tail, m, picUnion(acc, cr))
+    else
+      picBoundsKids(tail, m, acc)
 fun picInBox(x: Float, y: Float, w: Float, h: Float, px: Float, py: Float) -> Bool =
   px >= x && px <= x + w && py >= y && py <= y + h
-fun picNearLine(l: LineShape, px: Float, py: Float) -> Bool =
+fun picNearLine(x1: Float, y1: Float, x2: Float, y2: Float, thickness: Float, px: Float, py: Float) -> Bool =
-  dx := l.x2 - l.x1
+  dx := x2 - x1
-  dy := l.y2 - l.y1
+  dy := y2 - y1
   len2 := dx * dx + dy * dy
-  t := if len2 == 0.0 then 0.0 else {{px - l.x1} * dx + {py - l.y1} * dy} / len2
+  t := if len2 == 0.0 then 0.0 else {{px - x1} * dx + {py - y1} * dy} / len2
   tc := t.max(0.0).min(1.0)
-  qx := l.x1 + dx * tc
+  qx := x1 + dx * tc
-  qy := l.y1 + dy * tc
+  qy := y1 + dy * tc
-  Math.hypot(px - qx, py - qy) <= l.thickness.max(1.0) / 2.0
+  Math.hypot(px - qx, py - qy) <= thickness.max(1.0) / 2.0
 fun picLeaf(hit: Bool) -> List[Int]? =
   if hit
     return List[Int]()
   null
+# `i` followed by the path `sub`.
+fun picPrepend(i: Int, sub: List[Int]) -> List[Int] =
+  path := List(i)
+  for j := range sub.length()
+    path.push(sub.at(j))
+  path
 # The child indices from `node` down to the hit leaf, or null on a miss. A leaf
 # that is hit is an empty path. (px, py) is in `node`'s own space.
-fun picHit(node: SceneNode, px: Float, py: Float) -> List[Int]? =
+fun picHit(node: SceneNode, px: Float, py: Float) -> List[Int]? = match node
-  match node
-    RectShape => picLeaf(picInBox(node.x, node.y, node.w, node.h, px, py))
+  RectShape(x, y, w, h, _) => picLeaf(picInBox(x, y, w, h, px, py))
-    CircleShape => picLeaf(Math.hypot(px - node.cx, py - node.cy) <= node.r)
+  CircleShape(cx, cy, r, _) => picLeaf(Math.hypot(px - cx, py - cy) <= r)
-    LineShape => picLeaf(picNearLine(node, px, py))
+  LineShape(x1, y1, x2, y2, th, _) => picLeaf(picNearLine(x1, y1, x2, y2, th, px, py))
-    Sprite => picLeaf(picInBox(node.x, node.y, node.w, node.h, px, py))
+  Sprite(_, sx, sy, sw, sh, _, _, _, _, _) => picLeaf(picInBox(sx, sy, sw, sh, px, py))
-    Text => picLeaf(picInBox(node.x, node.y, node.size * 0.6 * Float(node.text.length()), node.size, px, py))
+  Text(txt, tx, ty, size, _) => picLeaf(picInBox(tx, ty, size * 0.6 * Float(txt.length()), size, px, py))
-    Group =>
+  Group(tr, kids) =>
-      inv := picCompose(Affine.Identity, node.transform).invert()
-      if gi := inv
+    if gi := picMatrix(tr).invert()
-        lp := gi.apply(Vec2(x: px, y: py))
+      lp := gi.apply(Vec2(x: px, y: py))
-        i := node.children.length() - 1
-        while i >= 0
-          sub := picHit(node.children.at(i), lp.x, lp.y)
+      picHitKids(kids, 0, lp.x, lp.y)
-          if sp := sub
-            path := List(i)
-            for j := range sp.length()
-              path.push(sp.at(j))
-            return path
+    else
-          i = i - 1
       null
-    Filter =>
+  Filter(_, child, _) =>
-      fsub := picHit(node.child, px, py)
+    if fp := picHit(child, px, py)
-      if fp := fsub
-        fpath := List(0)
-        for k := range fp.length()
-          fpath.push(fp.at(k))
+      picPrepend(0, fp)
-        return fpath
+    else
       null
+# Tries the later children first (they are drawn on top); `i` is the index of
+# `kids`' head. The first hit found from the back wins.
+fun picHitKids(kids: Nodes, i: Int, px: Float, py: Float) -> List[Int]? = match kids
+  End => null
+  More(head, tail) =>
+    if later := picHitKids(tail, i + 1, px, py)
+      later
+    else
+      if sub := picHit(head, px, py)
+        picPrepend(i, sub)
+      else
+        null
-fun picDraw(node: SceneNode, m: Affine, alpha: Float, target: Int) =
+fun picDraw(node: SceneNode, m: Affine, alpha: Float, target: Int) = match node
-  match node
-    RectShape =>
+  RectShape(x, y, w, h, color) =>
-      sx := node.w * m.scaleX()
+    sx := w * m.scaleX()
-      sy := node.h * m.scaleY()
+    sy := h * m.scaleY()
-      c := m.apply(Vec2(x: node.x + node.w / 2.0, y: node.y + node.h / 2.0))
+    c := m.apply(Vec2(x: x + w / 2.0, y: y + h / 2.0))
-      drawRect(c.x - sx / 2.0, c.y - sy / 2.0, sx, sy, node.color.withAlpha(node.color.a * alpha))
+    drawRect(c.x - sx / 2.0, c.y - sy / 2.0, sx, sy, color.withAlpha(color.a * alpha))
-    CircleShape =>
+  CircleShape(cx, cy, r, ccolor) =>
-      cc := m.apply(Vec2(x: node.cx, y: node.cy))
+    cc := m.apply(Vec2(x: cx, y: cy))
-      drawCircle(cc.x, cc.y, node.r * m.scaleX(), node.color.withAlpha(node.color.a * alpha))
+    drawCircle(cc.x, cc.y, r * m.scaleX(), ccolor.withAlpha(ccolor.a * alpha))
-    LineShape =>
+  LineShape(x1, y1, x2, y2, th, lcolor) =>
-      p := m.apply(Vec2(x: node.x1, y: node.y1))
+    p := m.apply(Vec2(x: x1, y: y1))
-      q := m.apply(Vec2(x: node.x2, y: node.y2))
+    q := m.apply(Vec2(x: x2, y: y2))
-      drawLine(p.x, p.y, q.x, q.y, node.thickness * m.scaleX(), node.color.withAlpha(node.color.a * alpha))
+    drawLine(p.x, p.y, q.x, q.y, th * m.scaleX(), lcolor.withAlpha(lcolor.a * alpha))
-    Sprite =>
+  Sprite(tex, sx0, sy0, sw0, sh0, srcX, srcY, srcW, srcH, tint) =>
-      sw := node.w * m.scaleX()
+    sw := sw0 * m.scaleX()
-      sh := node.h * m.scaleY()
+    sh := sh0 * m.scaleY()
-      sc := m.apply(Vec2(x: node.x + node.w / 2.0, y: node.y + node.h / 2.0))
+    sc := m.apply(Vec2(x: sx0 + sw0 / 2.0, y: sy0 + sh0 / 2.0))
-      drawTextureEx(node.tex, node.srcX, node.srcY, node.srcW, node.srcH, sc.x - sw / 2.0, sc.y - sh / 2.0, sw, sh, m.rotation(), false, node.tint.withAlpha(node.tint.a * alpha))
+    drawTextureEx(tex, srcX, srcY, srcW, srcH, sc.x - sw / 2.0, sc.y - sh / 2.0, sw, sh, m.rotation(), false, tint.withAlpha(tint.a * alpha))
-    Text =>
+  Text(txt, tx, ty, size, tcolor) =>
-      tp := m.apply(Vec2(x: node.x, y: node.y))
+    tp := m.apply(Vec2(x: tx, y: ty))
-      drawText(node.text, tp.x, tp.y, node.size * m.scaleY(), node.color.withAlpha(node.color.a * alpha))
+    drawText(txt, tp.x, tp.y, size * m.scaleY(), tcolor.withAlpha(tcolor.a * alpha))
-    Group =>
-      gm := picCompose(m, node.transform)
-      for i := range node.children.length()
-        picDraw(node.children.at(i), gm, alpha, target)
+  Group(tr, kids) => picDrawKids(kids, m.mul(picMatrix(tr)), alpha, target)
-    Filter => picFilter(node, m, alpha, target)
+  Filter(effect, child, tex) => picFilter(effect, child, tex, m, alpha, target)
-fun picFilter(f: Filter, m: Affine, alpha: Float, target: Int) =
+fun picDrawKids(kids: Nodes, m: Affine, alpha: Float, target: Int) = match kids
-  fx := f.effect
+  End => 0
-  match fx
+  More(head, tail) =>
+    picDraw(head, m, alpha, target)
+    picDrawKids(tail, m, alpha, target)
+fun picFilter(effect: Effect, child: SceneNode, tex: Int, m: Affine, alpha: Float, target: Int) = match effect
-    BlendFx =>
+  BlendFx(mode) =>
-      blendMode(fx.mode)
+    blendMode(mode)
-      picDraw(f.child, m, alpha, target)
+    picDraw(child, m, alpha, target)
-      blendMode(Blend.Normal)
+    blendMode(Blend.Normal)
-    _ =>
+  _ =>
-      fb := picBounds(f.child, m)
+    if b := picBounds(child, m)
-      if b := fb
-        tex := f.target
-        if tex < 0
+      if tex >= 0
-          return
         w := {Int(b.w) + 1}.min(textureWidth(tex))
         h := {Int(b.h) + 1}.min(textureHeight(tex))
         renderTarget(tex)
         clear(Color.Transparent)
         shift := Affine(a: 1.0, b: 0.0, c: 0.0, d: 1.0, e: 0.0 - b.x, f: 0.0 - b.y)
-        picDraw(f.child, shift.mul(m), 1.0, tex)
+        picDraw(child, shift.mul(m), 1.0, tex)
         renderTarget(target)
-        picComposite(f.effect, tex, b, alpha, w, h)
+        picComposite(effect, tex, b, alpha, w, h)
-fun picTint(e: Effect, alpha: Float) -> Color =
+fun picTint(e: Effect, alpha: Float) -> Color = match e
-  match e
-    Tint => e.color.withAlpha(e.color.a * alpha)
+  Tint(color) => color.withAlpha(color.a * alpha)
-    Alpha => Color.White.withAlpha(e.alpha * alpha)
+  Alpha(a) => Color.White.withAlpha(a * alpha)
-    _ => Color.White.withAlpha(alpha)
+  _ => Color.White.withAlpha(alpha)
 fun picComposite(e: Effect, tex: Int, b: Rect, alpha: Float, w: Int, h: Int) =
   drawTextureEx(tex, 0.0, 0.0, Float(w), Float(h), b.x, b.y, Float(w), Float(h), 0.0, false, picTint(e, alpha))
 primitive Picture =
-  # Draws the picture to the current target with a matrix stack.
+  # Draws the picture to the current target, recursing with the parent matrix and alpha.
   fun draw(node: SceneNode) =
     picDraw(node, Affine.Identity, 1.0, 0 - 1)
@@ -238,8 +232,11 @@ primitive Picture =
 fun picNear(a: Float, b: Float) -> Bool =
   {a - b}.abs() < 1e-6
+fun picRect(x: Float, y: Float, w: Float, h: Float, c: Color) -> SceneNode =
+  RectShape(x: x, y: y, w: w, h: h, color: c)
 test "bounds_translate_scale"
-  g := Group(transform: List(Translate(dx: 5.0, dy: 5.0), Scale(sx: 2.0, sy: 2.0)), children: List(RectShape(x: 0.0, y: 0.0, w: 10.0, h: 10.0, color: Color.Red)))
+  g := Group(transform: Compose(first: Translate(dx: 5.0, dy: 5.0), then: Scale(sx: 2.0, sy: 2.0)), children: More(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Red), tail: End))
   r := Picture.bounds(g)
   assert picNear(r.x, 5.0)
   assert picNear(r.y, 5.0)
@@ -247,7 +244,7 @@ test "bounds_translate_scale"
   assert picNear(r.h, 20.0)
 test "bounds_rotate_quarter"
-  g := Group(transform: List(Rotate(radians: 1.5707963267948966)), children: List(RectShape(x: 0.0, y: 0.0, w: 10.0, h: 4.0, color: Color.Red)))
+  g := Group(transform: Rotate(radians: 1.5707963267948966), children: More(head: picRect(0.0, 0.0, 10.0, 4.0, Color.Red), tail: End))
   r := Picture.bounds(g)
   assert picNear(r.x, 0.0 - 4.0)
   assert picNear(r.y, 0.0)
@@ -255,7 +252,8 @@ test "bounds_rotate_quarter"
   assert picNear(r.h, 10.0)
 test "hit_path_nested"
-  g := Group(transform: List[Transform](), children: List(RectShape(x: 0.0, y: 0.0, w: 10.0, h: 10.0, color: Color.Red), Group(transform: List(Translate(dx: 10.0, dy: 0.0)), children: List(RectShape(x: 0.0, y: 0.0, w: 10.0, h: 10.0, color: Color.Blue)))))
+  inner := Group(transform: Translate(dx: 10.0, dy: 0.0), children: More(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Blue), tail: End))
+  g := Group(transform: Identity, children: More(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Red), tail: More(head: inner, tail: End)))
   p := Picture.hitPath(g, 15.0, 5.0)
   assert p.length() == 2
   assert p.at(0) == 1
@@ -264,12 +262,18 @@ test "hit_path_nested"
   assert q.length() == 1
   assert q.at(0) == 0
+test "hit_path_last_child_wins"
+  g := Group(transform: Identity, children: More(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Red), tail: More(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Blue), tail: End)))
+  p := Picture.hitPath(g, 5.0, 5.0)
+  assert p.length() == 1
+  assert p.at(0) == 1
 test "hit_miss_empty"
-  g := Group(transform: List[Transform](), children: List(RectShape(x: 0.0, y: 0.0, w: 10.0, h: 10.0, color: Color.Red)))
+  g := Group(transform: Identity, children: More(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Red), tail: End))
   assert Picture.hitPath(g, 50.0, 50.0).length() == 0
 test "filter_bounds_is_child_bounds"
-  g := Filter(effect: Alpha(alpha: 0.5), child: RectShape(x: 1.0, y: 2.0, w: 10.0, h: 4.0, color: Color.Red), target: 0 - 1)
+  g := Filter(effect: Alpha(alpha: 0.5), child: picRect(1.0, 2.0, 10.0, 4.0, Color.Red), target: 0 - 1)
   r := Picture.bounds(g)
   assert picNear(r.x, 1.0)
   assert picNear(r.y, 2.0)

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

@@ -4745,8 +4745,16 @@ fn compileFnBodyImpl(
         idx += leafCount(ty);
     }
     for (name, ty) in &collector.named {
-        locals.insert(name.clone(), idx);
         let vts = withGcTypes(|g| flatValtypes(ty, g));
+        // `s = T(..s, ...)` on a param reassigns the param's own slot (F-T6-3): a
+        // fresh local would shadow the param for the whole body, so every read of
+        // `s` (the right-hand side included) would see the unset local.
+        if let Some(pty) = decl_types.get(name).filter(|_| locals.contains_key(name)) {
+            if withGcTypes(|g| flatValtypes(pty, g)) == vts {
+                continue;
+            }
+        }
+        locals.insert(name.clone(), idx);
         idx += vts.len() as u32;
         groups.extend(vts);
     }

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

@@ -204,3 +204,53 @@ fun main() -> Int =
 ");
     assert_eq!(runInt("match_rename", &src), 400 + 56);
 }
+/// F-T6-3: `s = Cell(..s, ...)` on a param must reassign the param's own slot, not
+/// a fresh shadow local that every read of `s` (the spread source included) sees unset.
+#[test]
+fn own_spread_reassign_same_var() {
+    let body = "own record Cell(x: Int, y: Int)
+fun bump(own s: Cell) -> Cell =
+  s = Cell(..s, x: s.x + 1)
+  s
+fun inc(n: Int) -> Int =
+  n = n + 1
+  n
+fun main() -> Int =
+  t := bump(Cell(x: 1, y: 7))
+  t.x * 100 + t.y + inc(40) * 1000
+";
+    let own = prog(body);
+    assert_eq!(runInt("reassign_param", &own), 41000 + 207);
+    let plain = prog(&body.replace("own record", "record").replace("own s", "s"));
+    assert_eq!(runInt("reassign_param_plain", &plain), 41000 + 207);
+    assert_eq!(structNewCount("reassign_param_p", &plain), structNewCount("reassign_param_o", &own) + 1);
+}
+#[test]
+fn own_spread_reassign_local() {
+    let src = prog("own record Cell(x: Int, y: Int)
+fun main() -> Int =
+  s := Cell(x: 1, y: 7)
+  s = Cell(..s, x: s.x + 1)
+  s = Cell(..s, y: s.y + s.x)
+  s.x * 100 + s.y
+");
+    assert_eq!(runInt("reassign_local", &src), 200 + 9);
+}
+#[test]
+fn own_self_spread_return() {
+    let src = prog("own record Cell(x: Int, y: Int) =
+  fun step(own self) -> Cell = Cell(..self, x: self.x + 1)
+fun main() -> Int =
+  t := Cell(x: 1, y: 7).step().step()
+  t.x * 100 + t.y
+");
+    assert_eq!(runInt("self_spread", &src), 300 + 7);
+}