217e404 | plum | pyrossh

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

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

217e404 — Peter John 2026-11-04T15:26:24+05:30

Input step 3: typed messages for the functional scene; TRMC typing fix

Files changed (10) hide show

README.md +7 -5
docs/backlog.md +1 -1
docs/game-scene-styles.md +11 -9
plum-core/src/trmc.rs +42 -1
plum-examples/games/functional/game_state_view.plum +49 -43
plum-examples/recursion.plum +19 -0
plum-game/web-test/fixtures/stress_state_view.plum +12 -12
plum-game/web-test/fixtures/stress_state_view_deep.plum +9 -9
plum-std/game/functional/FunctionalScene.plum +78 -52
plum-std/game/functional/Ui.plum +30 -8

README.md CHANGED Viewed

@@ -1404,17 +1404,19 @@ Three scene styles ship, each in its own folder: `std/game/imperative/Scene` (ac
 The functional game is written in a component style: each kind of thing is a record with an `update(self, ..)` that returns the next value and a `render(self, ..)` that returns its `SceneNode` (`Ship.update`/`Ship.render`, `Orb`, `Mine`, `Star`), and `State.render` composes them. `update` never changes a value it was given.
 - **`Anim`** describes motion as a function of time: `MoveBy`, `RotateBy`, `ScaleTo`, `Delay`, `Seq`, `Par` and `Forever`. `Anim.at(anim, t)` returns an `AnimPose` (dx, dy, rotation, scaleX, scaleY) for any `t`, so a view just applies the pose for `state.clock`.
-- **`Ui`** is pure pointer state. `view.hitId(x, y)` finds the `Tagged(id, child)` node under the pointer; `Ui.step(ui, input, hit)` returns a `UiStep` with the new `UiState` and the `UiEvent`s raised (`Press`, `Release`, `Click`, `Enter`, `Exit`, with pointer capture). `Ui.button(id, label, x, y, w, h, ui)` builds a tagged button that shows hover and pressed looks.
+- **`Ui`** is pure pointer state. `view.hitId(x, y)` finds the `Clickable(id, msg, child)` node under the pointer; `Ui.step(ui, input, hit)` returns a `UiStep` with the new `UiState` and the `UiEvent`s raised (`Press`, `Release`, `Click`, `Enter`, `Exit`, with pointer capture), and `Ui.messages(view, events)` turns the clicks into the game's own messages. `Ui.button(id, msg, label, x, y, w, h, ui)` builds a button that shows hover and pressed looks and sends `msg` when clicked. The picture is a `SceneNode[Msg]`, generic over the game's message type.
 From [`game_state_view.plum`](plum-examples/games/functional/game_state_view.plum) (a method of `State`): `feed` runs `Ui.step` against the picture the player sees, then hands each event to `update`.
 ```
-fun feed(self, input: UiInput) -> State =
+fun feed(self, input: Input) -> State =
+  pos := input.position() ?: return self
+  view := self.render()
-  r := Ui.step(self.ui, input, self.render().hitId(input.x, input.y))
+  r := Ui.step(self.ui, input, view.hitId(pos.x, pos.y))
-  r.events.fold(State(..self, ui: r.ui), |s, e| s.update(UiEv(event: e)))
+  Ui.messages(view, r.events).fold(State(..self, ui: r.ui), |s, m| s.update(m))
 ```
-Record `==` is identity today (structural `==` is a deferred item), so compare events by their fields (`e.id`, `e.kind`) as above.
+The button's id only identifies it for hover and press state (record `==` is identity today, structural `==` is a deferred item); what a click means is its message.
 **Browser check:** `cargo run --manifest-path plum-game/web-test/Cargo.toml -- plum-examples/games/imperative/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/backlog.md CHANGED Viewed

@@ -39,4 +39,4 @@ Open work, in the order the user queued it, plus smaller items found during buil
 - **Retire PureScene?** — after the component-style functional game, decide whether `std/game/pure` + `games/pure` stay. (Decision record §4b)
 - **`adder(1)(2)`** (calling a returned closure directly) is not supported. (functional-gaps plan)
 - **Fusion past a closure-spec copy on `Nil` miscompiles** — in `drive.rs` `quiet`, resolving `Nil.fold$c0(..)` to `List.fold$c0` (read-only) lets a value move past it, and codegen then fails with `unknown method 'List.fold$c0'` (5 `closure_spec_test` cases). `typeNameMethodKey` skips `$` copies until this is fixed.
-- **Input model** — steps 1 (shared `Input`, keys included) and 2 (`onInput` on actors, focus) built 2026-11-04; step 3 (typed `Msg` events) in [game-scene-styles.md](game-scene-styles.md) section 6.
+- **Input model** — steps 1-3 built 2026-11-04 (typed `Msg` events for the functional style only); see [game-scene-styles.md](game-scene-styles.md) section 6.

docs/game-scene-styles.md CHANGED Viewed

@@ -21,7 +21,7 @@ Decisions behind the styles are in [decisions/2026-11-language-and-scene-decisio
 ### Main API (after the 2026-11-04 method refactor)
 - **Pure:** `Node.group/sprite/label/button/custom(..)` build nodes. `node.update(dt)`, `node.drawTree(io, m, tint)`, `node.findHit(m, p)`, `node.findPath(id)`, `node.modify(id, f)`, `node.route(path, depth, e)` and `node.onPointer(e)` work on them. `Stage.create(root)`, `stage.frame(dt, inputs)`, `stage.draw(io)` and `Input.poll(io, wasDown)` run a frame. `Action.moveBy/rotateBy/delay/sequence/parallel/forever(..)` and `action.step(pose, dt)` drive animations.
-- **Functional:** `SceneNode` is an enum (`Group`, `Filter`, `Sprite`, `Text`, `RectShape`, `CircleShape`, `LineShape`, `Tagged`). `node.draw(io)`, `node.bounds()`, `node.hitPath(x, y)` and `node.hitId(x, y)` use it. `Transform.matrix()`, `Effect.tint(alpha)` and `Rect` methods are the helpers. `Ui.step(ui, input, hitId)` and `Ui.button(..)` handle UI.
+- **Functional:** `SceneNode[M]` is an enum over the game's message type `M` (`Group`, `Filter`, `Sprite`, `Text`, `RectShape`, `CircleShape`, `LineShape`, `Clickable`). `node.draw(io)`, `node.bounds()`, `node.hitPath(x, y)` and `node.hitId(x, y)` use it. `Transform.matrix()`, `Effect.tint(alpha)` and `Rect` methods are the helpers. `Ui.step(ui, input, hitId)` and `Ui.button(..)` handle UI.
 ## 2. Engine analogies
@@ -36,7 +36,7 @@ Decisions behind the styles are in [decisions/2026-11-language-and-scene-decisio
 Both avoid mutation in game logic. The difference is **where the state lives**:
 - In **pure**, the tree *is* the game state. Changing the game means finding a node (`findPath`, `modify`) and returning a new tree. Nodes carry their own behaviour (`Actor`) and animations (`actions`), and pointer input changes nodes (a button's `pressed`/`over`).
-- In **functional**, the tree is a *picture of* the game state. Changing the game means changing `State`; the next `render()` reflects it. Hover and press state lives in `UiState` inside `State`, and buttons are found with `Tagged(id, ..)` + `hitId`.
+- In **functional**, the tree is a *picture of* the game state. Changing the game means changing `State`; the next `render()` reflects it. Hover and press state lives in `UiState` inside `State`, and a click on a `Clickable(id, msg, ..)` becomes the game message `msg`.
 Cost: pure updates run in place when the compiler proves uniqueness. Functional describes the whole frame each time, but fusion removes the tree (see `fusion_alloc_test.rs`, `state_view_draw_has_no_scenenode_alloc`).
@@ -83,7 +83,7 @@ Steps 1 and 2 of the proposal below are built (2026-11-04).
 The example games and fixtures poll once per frame and feed every input in. Nothing else reads input from the host.
-Remaining problem: events still identify UI elements by integer id (`e.id == Id.Restart && e.kind == Click`); step 3 addresses it.
+In the functional style, clicks arrive as the game's own messages (step 3). The pure and imperative styles still identify UI elements by integer id.
 ## 6. Proposal: one input model with `onInput`
@@ -114,16 +114,18 @@ Its ideas:
 - **Imperative:** `trait Actor` has `fun onInput(self, e: Input) -> Bool` (e in the actor's coordinates; true = consumed). `stage.input(e) -> Bool` bubbles from the hit actor through `parent`. A press sets `stage.focus`; keys bubble from the focused actor.
 - **Functional:** no methods on nodes (they are data). Inputs reach `State.update` as `Event(input)` messages.
-### Step 3 (optional): typed messages instead of ids (needs generics)
+### Step 3: typed messages (built for the functional style)
-- **Functional:** `SceneNode[Msg]` gains `OnClick(msg: Msg, child: SceneNode[Msg])` and similar, and `Ui.step` returns `List[Msg]`. The game writes `Ui.button(Restart, "Again", ..)` and `match msg Restart => ..`; no ids, and the compiler checks every message is handled.
-- **Pure:** `Node[Msg]`, `Button(.., onClick: Msg)`, `Actor[Msg]`.
-- **This reopens a decision:** generic `Node[K]`/`Actor[Msg]` was rejected on 2026-11-03 ("Generics can be tried later"), and generic traits are not supported yet. A generic *enum* (`SceneNode[Msg]`) is supported, so the functional style could try it first, but fusion of `render().draw(io)` must be checked on a generic `SceneNode`.
+- `SceneNode[M]` is generic over the game's message type. `Clickable(id, msg: M, child)` replaces `Tagged(id, child)`. `node.msgOf(id)` reads a clickable's message.
+- `Ui.button(id, msg, label, ..)` builds one. `Ui.messages(view, events)` turns the Clicks that `Ui.step` raised into the game's own messages, read from the view the pointer was on.
+- The game declares `RestartClicked` in its `Msg` and handles it in `update` like any other message. The `UiEv` wrapper and the `e.id == Id.Restart && e.kind == Click` check are gone. The id stays only to identify the button for hover and press state (`Ui` needs identity, and `==` on records is identity).
+- Cost: every scene signature says `SceneNode[Msg]`, and a local built from a bare constructor needs an annotation (`x: SceneNode[Msg] := Group(..)`); passing it straight to its use (`Filter(child: Group(..))`) avoids that, and also keeps fusion. Helpers that do not mention `M` (`hitLeaf`, `hitPrepend`, `nearLine`) are top-level functions, because a static method of a generic type must mention its parameter. Fusion of `render().draw(io)` still holds (`fusion_alloc_test`); allocations in the exempt panel/animation functions went from 15 to 12.
+- Found on the way: TRMC hoisted a list cell's head into an untyped temporary, so `Cons(head: Full(..), ..)` in a function returning `List[Box[Int]]` gave the temporary a `Box` with its own parameter left open, and produced invalid wasm. Fixed in `trmc.rs` (the temporary takes the field's concrete type); regression test `trmc_list_of_generic_enum` in `plum-examples/recursion.plum`.
+- Pure and imperative styles keep integer ids (generic traits, `Actor[Msg]`, are not supported).
 ### Next
-1. Step 3 on the functional style only, kept if fusion still holds.
-2. Decide whether PureScene stays (backlog: "Retire PureScene?").
+1. Decide whether PureScene stays (backlog: "Retire PureScene?").
 ### Open questions

plum-core/src/trmc.rs CHANGED Viewed

@@ -60,6 +60,43 @@ struct Cx<'a> {
     found: bool,
 }
+impl Cx<'_> {
+    /// The declared type of field `field` of the cons variant `cons`, with the return
+    /// enum's own generic parameters replaced by the return type's arguments
+    /// (`head: T` of `List[T]` is `Box[Int]` when returning `List[Box[Int]]`). None
+    /// when it can't be told.
+    fn fieldType(&self, cons: &str, field: &str) -> Option<Type> {
+        let owner = self.enums.iter().find(|e| e.name == self.ret.name)?;
+        let v = owner.variants.iter().find(|v| v.name == cons).or_else(|| {
+            self.enums.iter().find(|e| e.name == cons).and_then(|e| e.variants.first())
+        })?;
+        let i = v.field_names.iter().position(|n| n == field)?;
+        let declared = v.fields.get(i)?;
+        if owner.generics.len() != self.ret.generics.len() {
+            return None;
+        }
+        let map: Vec<(&str, &Type)> =
+            owner.generics.iter().map(|g| g.name.as_str()).zip(self.ret.generics.iter()).collect();
+        fn subst(t: &Type, map: &[(&str, &Type)]) -> Type {
+            if t.generics.is_empty() {
+                if let Some((_, r)) = map.iter().find(|(n, _)| *n == t.name) {
+                    return (*r).clone();
+                }
+            }
+            Type { name: t.name.clone(), generics: t.generics.iter().map(|g| subst(g, map)).collect() }
+        }
+        fn open(t: &Type) -> bool {
+            (t.name.len() == 1 && t.name.chars().all(|c| c.is_ascii_uppercase())) || t.generics.iter().any(open)
+        }
+        // Only a concrete type helps (and a generic fn's own `B` would not re-check).
+        let t = subst(declared, &map);
+        if open(&t) {
+            return None;
+        }
+        Some(t)
+    }
+}
 fn rewriteFn(f: &Fn, enums: &[Enum]) -> Option<Fn> {
     if f.is_export
         || f.is_extern
@@ -442,7 +479,11 @@ impl<'a> Cx<'a> {
                 fields.push(FieldArg { name: f.name.clone(), value: Expr::TypeName(self.nullary.clone()) });
             } else if i < k && !pure(&f.value) {
                 let t = self.fresh("f");
+                // Typed from the field's declaration: a bare `Full(v: 1)` for a field
+                // `head: T` of `List[Box[Int]]` would otherwise leave `Box`'s own
+                // parameter open and get a different instantiation than the cell.
+                let ty = self.fieldType(&c.type_name, &f.name);
-                stmts.push(declare(&t, None, f.value.clone()));
+                stmts.push(declare(&t, ty, f.value.clone()));
                 fields.push(FieldArg { name: f.name.clone(), value: var(&t) });
             } else {
                 fields.push(f.clone());

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

@@ -16,7 +16,9 @@
 # player's input once a frame (`Input.poll`, its only input read) and sends each
 # `Input` to the state as an `Event`: keys update the held keys that steer the ship,
 # and a pointer input finds what is under it with `SceneNode.hitId` on the picture the
-# player is looking at, runs `Ui.step`, and feeds each `UiEvent` to `State.update`.
+# player is looking at and runs `Ui.step`. A click on a button sends the button's own
+# message (`RestartClicked`): `Ui.messages` reads it from the picture, and it goes to
+# `State.update` like any other `Msg`. The picture is a `SceneNode[Msg]`.
 # The game-over title and the ship's hurt flash are `Anim`s of time since they began.
 # The `World` record is the host shell: it holds the current `State`, polls the
 # keyboard and mouse into messages, and plays sounds.
@@ -71,10 +73,10 @@ record Spawned(at: Motion, rng: Random)
 fun frameOf(clock: Float, count: Int, fps: Float) -> Int =
   Int(clock * fps) % count
-fun nothing() -> SceneNode =
+fun nothing() -> SceneNode[Msg] =
   Group(transform: Identity, children: Nil)
-fun cell(sheet: Int, x: Float, y: Float, size: Float, col: Int, row: Int) -> SceneNode =
+fun cell(sheet: Int, x: Float, y: Float, size: Float, col: Int, row: Int) -> SceneNode[Msg] =
   Sprite(
     tex: sheet,
     x: x,
@@ -177,7 +179,7 @@ record Ship(x: Float, y: Float, vx: Float, vy: Float, rotation: Float, hurt: Flo
     overlaps(self.x, self.y, Rules.ShipRadius, at.x, at.y, radius)
   # The ship blinks while hurt (`hurtAge` seconds since the hit).
-  fun render(self, sheet: Int, clock: Float, hurtAge: Float) -> SceneNode =
+  fun render(self, sheet: Int, clock: Float, hurtAge: Float) -> SceneNode[Msg] =
     blink := self.hurt > 0.0 && flashPose(hurtAge).scaleX < 0.7
     if blink
       nothing()
@@ -204,18 +206,21 @@ record Orb(id: Int, at: Motion, phase: Float, clock: Float) =
     Orb(..self, at: Motion(..p, vx: 0.0, vy: 0.0))
   # The glow is drawn additively, then the sprite on top.
-  fun render(self, sheet: Int) -> SceneNode =
+  fun render(self, sheet: Int) -> SceneNode[Msg] =
-    glow := Group(
-      transform: Identity,
-      children: List(
-        CircleShape(cx: 0.0, cy: 0.0, r: 26.0, color: Color(r: 0.35, g: 0.22, b: 0.0, a: 0.5)),
-        CircleShape(cx: 0.0, cy: 0.0, r: 17.0, color: Color(r: 0.6, g: 0.4, b: 0.05, a: 0.5))
-      )
-    )
     Group(
       transform: Translate(dx: self.at.x, dy: self.at.y),
       children: List(
+        Filter(
-        Filter(effect: BlendFx(mode: Blend.Add), child: glow, target: 0 - 1),
+          effect: BlendFx(mode: Blend.Add),
+          child: Group(
+            transform: Identity,
+            children: List(
+              CircleShape(cx: 0.0, cy: 0.0, r: 26.0, color: Color(r: 0.35, g: 0.22, b: 0.0, a: 0.5)),
+              CircleShape(cx: 0.0, cy: 0.0, r: 17.0, color: Color(r: 0.6, g: 0.4, b: 0.05, a: 0.5))
+            )
+          ),
+          target: 0 - 1
+        ),
         cell(sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(self.clock + self.phase, 4, 8.0), 1)
       )
     )
@@ -233,7 +238,7 @@ record Mine(id: Int, at: Motion, rotation: Float, spin: Float, clock: Float) =
     p := self.at
     Mine(..self, at: Motion(..p, vx: 0.0, vy: 0.0), spin: 0.0)
-  fun render(self, sheet: Int) -> SceneNode =
+  fun render(self, sheet: Int) -> SceneNode[Msg] =
     Group(
       transform: Compose(first: Translate(dx: self.at.x, dy: self.at.y), then: Rotate(radians: self.rotation)),
       children: List(cell(sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(self.clock, 4, 4.0), 2))
@@ -246,7 +251,7 @@ record Star(i: Int) =
   fun field(i: Int) -> List[Star] =
     if i >= 40 then Nil else Cons(head: Star(i: i), tail: Star.field(i + 1))
-  fun render(self, clock: Float) -> SceneNode =
+  fun render(self, clock: Float) -> SceneNode[Msg] =
     r := 1.0 + Float(self.i % 3) * 0.5
     twinkle := 0.25 + 0.2 * Math.sin(clock * 2.0 + Float(self.i))
     CircleShape(cx: Float({self.i * 7919} % 800), cy: Float({self.i * 104729} % 600), r: r, color: Color(r: 0.7, g: 0.8, b: 1.0, a: twinkle))
@@ -257,7 +262,7 @@ enum Msg =
   | Resize(w: Float, h: Float)
   | Restart(seed: Int)
   | Event(input: Input)
-  | UiEv(event: UiEvent)
+  | RestartClicked
 # Everything that changes during a run. `sheet` and `target` are resource handles
 # the picture needs: the sprite sheet and the render target of the game-over filter.
@@ -314,7 +319,7 @@ record State(
     Resize(w, h) => State(..self, sw: w, sh: h)
     Restart(seed) => self.restarted(seed)
     Event(input) => self.onInput(input)
-    UiEv(event) => self.onUi(event)
+    RestartClicked => if self.over then self.restarted(self.rng.nextInt().value) else self
   # One frame of time. Once the game is over the actors only animate.
   fun tick(self, dt: Float, ax: Float, ay: Float) -> State =
@@ -417,16 +422,14 @@ record State(
   fun axisY(self) -> Float =
     axis(self.held.isDown(Key.Up) || self.held.isDown(Key.KeyW), self.held.isDown(Key.Down) || self.held.isDown(Key.KeyS))
-  # A click on the restart button restarts a finished game; other events change nothing.
-  fun onUi(self, e: UiEvent) -> State =
-    if self.over && e.id == Id.Restart && e.kind == Click then self.restarted(self.rng.nextInt().value) else self
-  # One pointer input: finds what is under it in the current picture, runs the Ui, and
+  # One pointer input: finds what is under it in the current picture, runs the Ui,
-  # feeds each raised event to `update`.
+  # and sends the messages of the buttons it clicked to `update`.
   fun feed(self, input: Input) -> State =
     pos := input.position() ?: return self
+    view := self.render()
-    r := Ui.step(self.ui, input, self.render().hitId(pos.x, pos.y))
+    r := Ui.step(self.ui, input, view.hitId(pos.x, pos.y))
-    r.events.fold(State(..self, ui: r.ui), |s, e| s.update(UiEv(event: e)))
+    Ui.messages(view, r.events).fold(State(..self, ui: r.ui), |s, m| s.update(m))
   # --- render ---
@@ -441,7 +444,7 @@ record State(
     {self.sh - self.zoom() * Rules.ArenaH} / 2.0
   # The whole picture, in drawing order, under the camera that fits the arena on screen.
-  fun render(self) -> SceneNode =
+  fun render(self) -> SceneNode[Msg] =
     z := self.zoom()
     Group(
       transform: Compose(first: Translate(dx: self.offsetX(), dy: self.offsetY()), then: Scale(sx: z, sy: z)),
@@ -457,18 +460,18 @@ record State(
     )
   # The ship is gone once the game is over (an empty group keeps the slots).
-  fun renderShip(self) -> SceneNode =
+  fun renderShip(self) -> SceneNode[Msg] =
     if self.over then nothing() else self.ship.render(self.sheet, self.clock, self.clock - self.hurtAt)
   # One life icon per remaining life, from the right edge going left.
-  fun lifeIcons(self, i: Int) -> List[SceneNode] =
+  fun lifeIcons(self, i: Int) -> List[SceneNode[Msg]] =
     if i >= self.lives
       Nil
     else
       Cons(head: cell(self.sheet, Rules.ArenaW - 40.0 - Float(i) * 36.0, 12.0, 32.0, 0, 0), tail: self.lifeIcons(i + 1))
   # `Cons` (not `List(..).append(..)`) so the life icons fuse into the draw walk too.
-  fun renderHud(self) -> SceneNode =
+  fun renderHud(self) -> SceneNode[Msg] =
     Group(
       transform: Identity,
       children: Cons(
@@ -477,7 +480,7 @@ record State(
       )
     )
-  fun renderTitle(self) -> SceneNode =
+  fun renderTitle(self) -> SceneNode[Msg] =
     p := titlePose(self.clock - self.overAt)
     Group(
       transform: Compose(first: Translate(dx: 400.0 + p.dx, dy: 268.0 + p.dy), then: Scale(sx: p.scaleX, sy: p.scaleY)),
@@ -485,22 +488,25 @@ record State(
     )
   # The game-over panel is empty while playing, so nothing in it can be hit.
-  fun renderOverlay(self) -> SceneNode =
+  fun renderOverlay(self) -> SceneNode[Msg] =
     if self.over then self.renderPanel() else nothing()
   # The panel with the restart button, faded in through a render-target filter.
-  fun renderPanel(self) -> SceneNode =
+  fun renderPanel(self) -> SceneNode[Msg] =
-    button := Ui.button(Id.Restart, "Again", 340.0, 342.0, 120.0, 44.0, self.ui)
+    button := Ui.button(Id.Restart, RestartClicked, "Again", 340.0, 342.0, 120.0, 44.0, self.ui)
+    Filter(
+      effect: Alpha(alpha: {self.overClock * 2.0}.min(1.0)),
-    panel := Group(
+      child: Group(
-      transform: Identity,
+        transform: Identity,
-      children: List(
+        children: List(
-        RectShape(x: 0.0, y: 230.0, w: Rules.ArenaW, h: 170.0, color: Color(r: 0.0, g: 0.0, b: 0.0, a: 0.6)),
+          RectShape(x: 0.0, y: 230.0, w: Rules.ArenaW, h: 170.0, color: Color(r: 0.0, g: 0.0, b: 0.0, a: 0.6)),
-        self.renderTitle(),
+          self.renderTitle(),
-        Text(text: "Press Enter to play again", x: 270.0, y: 300.0, size: 24.0, color: Color.White),
+          Text(text: "Press Enter to play again", x: 270.0, y: 300.0, size: 24.0, color: Color.White),
-        button
+          button
-      )
+        )
+      ),
+      target: self.target
     )
-    Filter(effect: Alpha(alpha: {self.overClock * 2.0}.min(1.0)), child: panel, target: self.target)
   # True when (x, y) in screen pixels is on the restart button of the picture `render` builds.
   fun onRestart(self, x: Float, y: Float) -> Bool =
@@ -604,12 +610,12 @@ fun onShip(s: State) -> Motion =
 fun forceOver(s: State) -> State =
   State(..s, lives: 0, over: true, overAt: s.clock, best: s.best.max(s.score))
-fun countNodes(n: SceneNode) -> Int = match n
+fun countNodes(n: SceneNode[Msg]) -> Int = match n
   Group(_, kids) => 1 + countKids(kids)
   Filter(_, child, _) => 1 + countNodes(child)
   _ => 1
-fun countKids(ks: List[SceneNode]) -> Int = match ks
+fun countKids(ks: List[SceneNode[Msg]]) -> Int = match ks
   Nil => 0
   Cons(h, t) => countNodes(h) + countKids(t)

plum-examples/recursion.plum CHANGED Viewed

@@ -76,6 +76,22 @@ record Cell(x: Float)
 # ==== tail calls tests ====
+# A generic enum kept in a List: TRMC must give the hoisted head the list's element
+# type (`Box[Int]`), not a `Box` with its own parameter left open (invalid wasm before).
+enum TrBox[M] =
+  | TrEmpty
+  | TrFull(v: Int)
+  | TrTag(id: Int, msg: M)
+fun trBoxes(xs: List[Int], rest: List[TrBox[Int]]) -> List[TrBox[Int]] = match xs
+  Nil => rest
+  Cons(h, t) => Cons(head: TrFull(v: h * 2), tail: trBoxes(t, rest))
+fun trSum(bs: List[TrBox[Int]]) -> Int = match bs
+  Nil => 0
+  Cons(TrFull(v), t) => v + trSum(t)
+  Cons(_, t) => trSum(t)
 test "tail_sum_million"
   assert sumTo(1000000, 0) == 500000500000
@@ -219,3 +235,6 @@ test "put_after_take_keeps_length"
   c := xs.takeAt(0)
   xs.putAt(0, c)
   assert xs.length() == 3
+test "trmc_list_of_generic_enum"
+  assert trSum(trBoxes(List(1, 2, 3), Nil)) == 12

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

@@ -57,11 +57,11 @@ fun nthOr(xs: List[T], i: Int, dflt: T) -> T = match xs
   Cons(h, t) => if i <= 0 then h else nthOr(t, i - 1, dflt)
 # The nodes f(x) for every x of `xs`, followed by `rest`.
-fun toNodes(xs: List[T], f: fn(T) -> SceneNode, rest: List[SceneNode]) -> List[SceneNode] = match xs
+fun toNodes(xs: List[T], f: fn(T) -> SceneNode[Int], rest: List[SceneNode[Int]]) -> List[SceneNode[Int]] = match xs
   Nil => rest
   Cons(h, t) => Cons(head: f(h), tail: toNodes(t, f, rest))
-fun countNodes(ns: List[SceneNode]) -> Int = match ns
+fun countNodes(ns: List[SceneNode[Int]]) -> Int = match ns
   Nil => 0
   Cons(_, t) => 1 + countNodes(t)
@@ -153,27 +153,27 @@ fun stepUi(s: State, input: Input) -> State =
 # --- view: pure, the whole tree every frame ---
-fun dancerView(sheet: Int, d: Dancer) -> SceneNode =
+fun dancerView(sheet: Int, d: Dancer) -> SceneNode[Int] =
   Group(
     transform: Compose(first: Translate(dx: d.x + 8.0, dy: d.y + 8.0), then: Compose(first: Rotate(radians: d.rotation), then: Translate(dx: 0.0 - 8.0, dy: 0.0 - 8.0))),
     children: Cons(head: Sprite(
       tex: sheet, x: 0.0, y: 0.0, w: 16.0, h: 16.0, srcX: d.srcX, srcY: 0.0, srcW: 16.0, srcH: 16.0,
       tint: Color.White), tail: Nil))
-fun spinnerView(sheet: Int, p: Spinner) -> SceneNode =
+fun spinnerView(sheet: Int, p: Spinner) -> SceneNode[Int] =
   Group(
     transform: Compose(first: Translate(dx: p.x + 75.0, dy: p.y + 85.0), then: Compose(first: Rotate(radians: p.rotation), then: Translate(dx: 0.0 - 75.0, dy: 0.0 - 85.0))),
     children: toNodes(p.dancers, |d| dancerView(sheet, d), Nil))
-fun drifterView(white: Int, d: Drifter) -> SceneNode =
+fun drifterView(white: Int, d: Drifter) -> SceneNode[Int] =
   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,
     tint: d.color)
-fun counterView(c: Counter) -> SceneNode =
+fun counterView(c: Counter) -> SceneNode[Int] =
   Text(text: "n {c.n}", x: c.x, y: c.y, size: 14.0, color: Color.White)
-fun pulserView(sheet: Int, anim: Anim, clock: Float, p: Pulser) -> SceneNode =
+fun pulserView(sheet: Int, anim: Anim, clock: Float, p: Pulser) -> SceneNode[Int] =
   pose := Anim.at(anim, clock - p.start)
   Group(
     transform: Compose(first: Translate(dx: p.x + pose.dx + 8.0, dy: p.y + pose.dy + 8.0), then: Compose(first: Scale(sx: pose.scaleX, sy: pose.scaleY), then: Compose(first: Rotate(radians: pose.rotation), then: Translate(dx: 0.0 - 8.0, dy: 0.0 - 8.0)))),
@@ -181,17 +181,17 @@ fun pulserView(sheet: Int, anim: Anim, clock: Float, p: Pulser) -> SceneNode =
       tex: sheet, x: 0.0, y: 0.0, w: 16.0, h: 16.0, srcX: p.srcX, srcY: 0.0, srcW: 16.0, srcH: 16.0,
       tint: Color.White), tail: Nil))
-fun buttonNodes(i: Int, ui: UiState) -> List[SceneNode] =
+fun buttonNodes(i: Int, ui: UiState) -> List[SceneNode[Int]] =
-  if i >= Counts.Buttons then Nil else Cons(head: Ui.button(40000 + i, "b{i}", Float(i % 10 * 70 + 10), Float(i / 10 * 30 + 10), 64.0, 24.0, ui), tail: buttonNodes(i + 1, ui))
+  if i >= Counts.Buttons then Nil else Cons(head: Ui.button(40000 + i, 40000 + i, "b{i}", Float(i % 10 * 70 + 10), Float(i / 10 * 30 + 10), 64.0, 24.0, ui), tail: buttonNodes(i + 1, ui))
-fun buttonsView(ui: UiState) -> SceneNode =
+fun buttonsView(ui: UiState) -> SceneNode[Int] =
   Group(transform: Identity, children: buttonNodes(0, ui))
-fun view(s: State) -> SceneNode =
+fun view(s: State) -> SceneNode[Int] =
   texts := toNodes(s.counters, |c| counterView(c), Nil)
   drifts := toNodes(s.drifters, |d| drifterView(s.white, d), texts)
   pulses := toNodes(s.pulsers, |p| pulserView(s.sheet, s.anim, s.clock, p), drifts)
-  world := Group(transform: Scale(sx: 0.8, sy: 0.8), children: toNodes(s.spinners, |p| spinnerView(s.sheet, p), pulses))
+  world: SceneNode[Int] := Group(transform: Scale(sx: 0.8, sy: 0.8), children: toNodes(s.spinners, |p| spinnerView(s.sheet, p), pulses))
   Group(transform: Identity, children: List(world, buttonsView(s.ui)))
 fun whiteTexture(io: Io) -> Int =

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

@@ -48,11 +48,11 @@ fun nthOr(xs: List[T], i: Int, dflt: T) -> T = match xs
   Cons(h, t) => if i <= 0 then h else nthOr(t, i - 1, dflt)
 # The nodes f(x) for every x of `xs`, followed by `rest`.
-fun toNodes(xs: List[T], f: fn(T) -> SceneNode, rest: List[SceneNode]) -> List[SceneNode] = match xs
+fun toNodes(xs: List[T], f: fn(T) -> SceneNode[Int], rest: List[SceneNode[Int]]) -> List[SceneNode[Int]] = match xs
   Nil => rest
   Cons(h, t) => Cons(head: f(h), tail: toNodes(t, f, rest))
-fun countNodes(ns: List[SceneNode]) -> Int = match ns
+fun countNodes(ns: List[SceneNode[Int]]) -> Int = match ns
   Nil => 0
   Cons(_, t) => 1 + countNodes(t)
@@ -122,7 +122,7 @@ fun step(s: State, dt: Float) -> State =
 # --- view: pure, the whole tree every frame ---
-fun dancerView(sheet: Int, d: Dancer) -> SceneNode =
+fun dancerView(sheet: Int, d: Dancer) -> SceneNode[Int] =
   Group(
     transform: Compose(first: Translate(dx: d.x + 8.0, dy: d.y + 8.0), then: Compose(first: Rotate(radians: d.rotation), then: Translate(dx: 0.0 - 8.0, dy: 0.0 - 8.0))),
     children: Cons(head: Sprite(
@@ -130,7 +130,7 @@ fun dancerView(sheet: Int, d: Dancer) -> SceneNode =
       tint: Color.White), tail: Nil))
 # The leading dancers of `ds` that belong to group `gi`, as nodes.
-fun groupNodes(sheet: Int, ds: List[Dancer], gi: Int) -> List[SceneNode] = match ds
+fun groupNodes(sheet: Int, ds: List[Dancer], gi: Int) -> List[SceneNode[Int]] = match ds
   Nil => Nil
   Cons(h, t) => if h.gi == gi then Cons(head: dancerView(sheet, h), tail: groupNodes(sheet, t, gi)) else Nil
@@ -139,25 +139,25 @@ fun dropGroup(ds: List[Dancer], gi: Int) -> List[Dancer] = match ds
   Nil => Nil
   Cons(h, t) => if h.gi == gi then dropGroup(t, gi) else ds
-fun spinnerView(sheet: Int, p: Spinner, ds: List[Dancer]) -> SceneNode =
+fun spinnerView(sheet: Int, p: Spinner, ds: List[Dancer]) -> SceneNode[Int] =
   Group(
     transform: Compose(first: Translate(dx: p.x + 75.0, dy: p.y + 85.0), then: Compose(first: Rotate(radians: p.rotation), then: Translate(dx: 0.0 - 75.0, dy: 0.0 - 85.0))),
     children: groupNodes(sheet, ds, p.id - 100))
 # Spinner groups in order, each taking its dancers from the front of the one list.
-fun spinnerNodes(sheet: Int, ps: List[Spinner], ds: List[Dancer], rest: List[SceneNode]) -> List[SceneNode] = match ps
+fun spinnerNodes(sheet: Int, ps: List[Spinner], ds: List[Dancer], rest: List[SceneNode[Int]]) -> List[SceneNode[Int]] = match ps
   Nil => rest
   Cons(p, t) => Cons(head: spinnerView(sheet, p, ds), tail: spinnerNodes(sheet, t, dropGroup(ds, p.id - 100), rest))
-fun drifterView(white: Int, d: Drifter) -> SceneNode =
+fun drifterView(white: Int, d: Drifter) -> SceneNode[Int] =
   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,
     tint: d.color)
-fun counterView(c: Counter) -> SceneNode =
+fun counterView(c: Counter) -> SceneNode[Int] =
   Text(text: "n {c.n}", x: c.x, y: c.y, size: 14.0, color: Color.White)
-fun view(s: State) -> SceneNode =
+fun view(s: State) -> SceneNode[Int] =
   texts := toNodes(s.counters, |c| counterView(c), Nil)
   drifts := toNodes(s.drifters, |d| drifterView(s.white, d), texts)
   Group(transform: Scale(sx: 0.8, sy: 0.8), children: spinnerNodes(s.sheet, s.spinners, s.dancers, drifts))

plum-std/game/functional/FunctionalScene.plum CHANGED Viewed

@@ -11,10 +11,13 @@ import std/game/Affine
 import std/game/Game
 import std/Io
-# The functional scene: a `SceneNode` is plain data (shapes, sprites, text, groups
+# The functional scene: a `SceneNode[M]` is plain data (shapes, sprites, text, groups
-# with a transform, filters), rebuilt every frame and never mutated. Its methods draw
+# with a transform, filters, clickable areas), rebuilt every frame and never mutated.
+# `M` is the game's own message type: a `Clickable(id, msg, child)` carries the
+# message a click on it sends (see `Ui.messages`), so games match on their messages
+# instead of comparing ids; the id identifies the element for hover and press state. Its methods draw
 # it, measure it and hit-test it by structural recursion, passing the parent matrix
-# and alpha down as arguments. Children are a `List[SceneNode]`; the static
+# and alpha down as arguments. Children are a `List[SceneNode[M]]`; the static
 # `SceneNode` helpers over such a list (`drawKids`, `boundsKids`, ..) do the same walk
 # for each child. `Compose(first, then)` applies `then` first, then `first` (`first`
 # is the outermost).
@@ -83,15 +86,15 @@ struct Rect(x: Float, y: Float, w: Float, h: Float) =
 # creates nothing, so a view does not leak a texture per frame. The size of
 # `target` bounds what the filter can show: child pixels beyond it are cut off.
 # A negative target draws nothing.
-enum SceneNode =
+enum SceneNode[M] =
-  | Group(transform: Transform, children: List[SceneNode])
+  | Group(transform: Transform, children: List[SceneNode[M]])
-  | Filter(effect: Effect, child: SceneNode, target: Int)
+  | Filter(effect: Effect, child: SceneNode[M], 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)
   | 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)
-  | Tagged(id: Int, child: SceneNode)
+  | Clickable(id: Int, msg: M, child: SceneNode[M])
   # Draws the scene to the current target.
   fun draw(self, io: Io) =
@@ -109,10 +112,25 @@ enum SceneNode =
       return p
     Slice[Int]()
-  # The id of the innermost Tagged node under (x, y), or null. Later siblings win.
+  # The id of the innermost Clickable node under (x, y), or null. Later siblings win.
   fun hitId(self, x: Float, y: Float) -> Int? =
     self.hitIdWith(null, x, y)
+  # The message of the first Clickable with `id`, depth first, or null.
+  fun msgOf(self, id: Int) -> M? = match self
+    Clickable(cid, msg, child) => if cid == id then msg else child.msgOf(id)
+    Group(_, kids) => SceneNode.msgOfKids(kids, id)
+    Filter(_, child, _) => child.msgOf(id)
+    _ => null
+  fun msgOfKids(kids: List[SceneNode[M]], id: Int) -> M? = match kids
+    Nil => null
+    Cons(head, tail) =>
+      if m := head.msgOf(id)
+        m
+      else
+        SceneNode.msgOfKids(tail, id)
   # --- drawing ---
   # Draws under the parent matrix `m` and alpha into `target` (negative: the screen).
@@ -139,15 +157,15 @@ enum SceneNode =
       io.drawText(txt, tp.x, tp.y, size * m.scaleY(), tcolor.withAlpha(tcolor.a * alpha))
     Group(tr, kids) => SceneNode.drawKids(io, kids, m.mul(tr.matrix()), alpha, target)
     Filter(effect, child, tex) => SceneNode.drawFiltered(io, effect, child, tex, m, alpha, target)
-    Tagged(_, child) => child.drawWith(io, m, alpha, target)
+    Clickable(_, _, child) => child.drawWith(io, m, alpha, target)
-  fun drawKids(io: Io, kids: List[SceneNode], m: Affine, alpha: Float, target: Int) = match kids
+  fun drawKids(io: Io, kids: List[SceneNode[M]], m: Affine, alpha: Float, target: Int) = match kids
     Nil => 0
     Cons(head, tail) =>
       head.drawWith(io, m, alpha, target)
       SceneNode.drawKids(io, tail, m, alpha, target)
-  fun drawFiltered(io: Io, effect: Effect, child: SceneNode, tex: Int, m: Affine, alpha: Float, target: Int) = match effect
+  fun drawFiltered(io: Io, effect: Effect, child: SceneNode[M], tex: Int, m: Affine, alpha: Float, target: Int) = match effect
     BlendFx(mode) =>
       io.blendMode(mode)
       child.drawWith(io, m, alpha, target)
@@ -175,9 +193,9 @@ enum SceneNode =
     Text(txt, tx, ty, size, _) => Rect.through(tx, ty, size * 0.6 * Float(txt.length()), size, m)
     Group(tr, kids) => SceneNode.boundsKids(kids, m.mul(tr.matrix()), null)
     Filter(_, child, _) => child.boundsWith(m)
-    Tagged(_, child) => child.boundsWith(m)
+    Clickable(_, _, child) => child.boundsWith(m)
-  fun boundsKids(kids: List[SceneNode], m: Affine, acc: Rect?) -> Rect? = match kids
+  fun boundsKids(kids: List[SceneNode[M]], m: Affine, acc: Rect?) -> Rect? = match kids
     Nil => acc
     Cons(head, tail) =>
       if cr := head.boundsWith(m)
@@ -190,11 +208,11 @@ enum SceneNode =
   # The child indices from the node down to the hit leaf, or null on a miss. A leaf
   # that is hit is an empty path. (px, py) is in the node's own space.
   fun hitWith(self, px: Float, py: Float) -> Slice[Int]? = match self
-    RectShape(x, y, w, h, _) => SceneNode.leaf(Rect(x: x, y: y, w: w, h: h).contains(px, py))
+    RectShape(x, y, w, h, _) => hitLeaf(Rect(x: x, y: y, w: w, h: h).contains(px, py))
-    CircleShape(cx, cy, r, _) => SceneNode.leaf(Math.hypot(px - cx, py - cy) <= r)
+    CircleShape(cx, cy, r, _) => hitLeaf(Math.hypot(px - cx, py - cy) <= r)
-    LineShape(x1, y1, x2, y2, th, _) => SceneNode.leaf(SceneNode.nearLine(x1, y1, x2, y2, th, px, py))
+    LineShape(x1, y1, x2, y2, th, _) => hitLeaf(nearLine(x1, y1, x2, y2, th, px, py))
-    Sprite(_, sx, sy, sw, sh, _, _, _, _, _) => SceneNode.leaf(Rect(x: sx, y: sy, w: sw, h: sh).contains(px, py))
+    Sprite(_, sx, sy, sw, sh, _, _, _, _, _) => hitLeaf(Rect(x: sx, y: sy, w: sw, h: sh).contains(px, py))
-    Text(txt, tx, ty, size, _) => SceneNode.leaf(Rect(x: tx, y: ty, w: size * 0.6 * Float(txt.length()), h: size).contains(px, py))
+    Text(txt, tx, ty, size, _) => hitLeaf(Rect(x: tx, y: ty, w: size * 0.6 * Float(txt.length()), h: size).contains(px, py))
     Group(tr, kids) =>
       if gi := tr.matrix().invert()
         lp := gi.apply(Vec2(x: px, y: py))
@@ -203,29 +221,29 @@ enum SceneNode =
         null
     Filter(_, child, _) =>
       if fp := child.hitWith(px, py)
-        SceneNode.prepend(0, fp)
+        hitPrepend(0, fp)
       else
         null
-    Tagged(_, child) =>
+    Clickable(_, _, child) =>
       if tp := child.hitWith(px, py)
-        SceneNode.prepend(0, tp)
+        hitPrepend(0, tp)
       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 hitKids(kids: List[SceneNode], i: Int, px: Float, py: Float) -> Slice[Int]? = match kids
+  fun hitKids(kids: List[SceneNode[M]], i: Int, px: Float, py: Float) -> Slice[Int]? = match kids
     Nil => null
     Cons(head, tail) =>
       if later := SceneNode.hitKids(tail, i + 1, px, py)
         later
       else
         if sub := head.hitWith(px, py)
-          SceneNode.prepend(i, sub)
+          hitPrepend(i, sub)
         else
           null
-  # The id of the innermost Tagged node whose subtree is hit at (px, py), or null.
+  # The id of the innermost Clickable node whose subtree is hit at (px, py), or null.
   # `outer` is the id of the nearest enclosing tag (null at the root).
   fun hitIdWith(self, outer: Int?, px: Float, py: Float) -> Int? = match self
     Group(tr, kids) =>
@@ -235,7 +253,7 @@ enum SceneNode =
       else
         null
     Filter(_, child, _) => child.hitIdWith(outer, px, py)
-    Tagged(id, child) => child.hitIdWith(id, px, py)
+    Clickable(id, _, child) => child.hitIdWith(id, px, py)
     _ =>
       if self.hitWith(px, py) != null
         outer
@@ -243,7 +261,7 @@ enum SceneNode =
         null
   # Later siblings are drawn on top, so they are tried first.
-  fun hitIdKids(kids: List[SceneNode], outer: Int?, px: Float, py: Float) -> Int? = match kids
+  fun hitIdKids(kids: List[SceneNode[M]], outer: Int?, px: Float, py: Float) -> Int? = match kids
     Nil => null
     Cons(head, tail) =>
       if later := SceneNode.hitIdKids(tail, outer, px, py)
@@ -251,32 +269,35 @@ enum SceneNode =
       else
         head.hitIdWith(outer, px, py)
+# Hit-test helpers that do not mention `M`. They are not static methods of
+# `SceneNode[M]` because a call like `SceneNode.leaf(..)` could not tell which `M`.
-  fun leaf(hit: Bool) -> Slice[Int]? =
+fun hitLeaf(hit: Bool) -> Slice[Int]? =
-    if hit
+  if hit
-      return Slice[Int]()
+    return Slice[Int]()
-    null
+  null
-  # `i` followed by the path `sub`.
+# `i` followed by the path `sub`.
-  fun prepend(i: Int, sub: Slice[Int]) -> Slice[Int] =
+fun hitPrepend(i: Int, sub: Slice[Int]) -> Slice[Int] =
-    path := Slice(i)
+  path := Slice(i)
-    for j := range sub.length()
+  for j := range sub.length()
-      path.push(sub.at(j))
+    path.push(sub.at(j))
-    path
+  path
-  fun nearLine(x1: Float, y1: Float, x2: Float, y2: Float, thickness: Float, px: Float, py: Float) -> Bool =
+fun nearLine(x1: Float, y1: Float, x2: Float, y2: Float, thickness: Float, px: Float, py: Float) -> Bool =
-    dx := x2 - x1
+  dx := x2 - x1
-    dy := y2 - y1
+  dy := y2 - y1
-    len2 := dx * dx + dy * dy
+  len2 := dx * dx + dy * dy
-    t := if len2 == 0.0 then 0.0 else {{px - x1} * dx + {py - 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)
+  tc := t.max(0.0).min(1.0)
-    qx := x1 + dx * tc
+  qx := x1 + dx * tc
-    qy := y1 + dy * tc
+  qy := y1 + dy * tc
-    Math.hypot(px - qx, py - qy) <= thickness.max(1.0) / 2.0
+  Math.hypot(px - qx, py - qy) <= thickness.max(1.0) / 2.0
 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 =
+fun picRect(x: Float, y: Float, w: Float, h: Float, c: Color) -> SceneNode[Int] =
   RectShape(x: x, y: y, w: w, h: h, color: c)
 test "bounds_translate_scale"
@@ -325,7 +346,7 @@ test "filter_bounds_is_child_bounds"
   assert picNear(r.h, 4.0)
 test "tagged_bounds_and_path"
-  g := Group(transform: Identity, children: Cons(head: Tagged(id: 7, child: picRect(1.0, 2.0, 10.0, 4.0, Color.Red)), tail: Nil))
+  g := Group(transform: Identity, children: Cons(head: Clickable(id: 7, msg: 7 * 10, child: picRect(1.0, 2.0, 10.0, 4.0, Color.Red)), tail: Nil))
   r := g.bounds()
   assert picNear(r.x, 1.0)
   assert picNear(r.w, 10.0)
@@ -335,9 +356,9 @@ test "tagged_bounds_and_path"
   assert p.at(1) == 0
 test "hit_id_innermost_and_topmost"
-  inner := Tagged(id: 2, child: picRect(0.0, 0.0, 10.0, 10.0, Color.Blue))
+  inner := Clickable(id: 2, msg: 2 * 10, child: picRect(0.0, 0.0, 10.0, 10.0, Color.Blue))
-  outer := Tagged(id: 1, child: Group(transform: Identity, children: Cons(head: picRect(0.0, 0.0, 20.0, 20.0, Color.Red), tail: Cons(head: inner, tail: Nil))))
+  outer := Clickable(id: 1, msg: 1 * 10, child: Group(transform: Identity, children: Cons(head: picRect(0.0, 0.0, 20.0, 20.0, Color.Red), tail: Cons(head: inner, tail: Nil))))
-  top := Tagged(id: 3, child: picRect(15.0, 15.0, 10.0, 10.0, Color.Red))
+  top := Clickable(id: 3, msg: 3 * 10, child: picRect(15.0, 15.0, 10.0, 10.0, Color.Red))
   g := Group(transform: Translate(dx: 1.0, dy: 0.0), children: Cons(head: outer, tail: Cons(head: top, tail: Nil)))
   a := g.hitId(6.0, 5.0)
   if va := a
@@ -355,3 +376,8 @@ test "hit_id_innermost_and_topmost"
   else
     assert false
   assert g.hitId(100.0, 100.0) == null
+test "msg_of_finds_the_clickable_message"
+  g := Group(transform: Identity, children: List(picRect(0.0, 0.0, 1.0, 1.0, Color.Red), Clickable(id: 4, msg: 40, child: picRect(0.0, 0.0, 1.0, 1.0, Color.Red))))
+  assert {g.msgOf(4) ?: -1} == 40
+  assert g.msgOf(5) == null

plum-std/game/functional/Ui.plum CHANGED Viewed

@@ -10,7 +10,9 @@ import std/game/Input
 # A pure UI layer for the functional scene style. `Ui.step` takes the previous
 # UiState, one pointer input and the id under the pointer (from SceneNode.hitId on
-# the current view) and returns the new state plus the UiEvents it raised. Same
+# the current view) and returns the new state plus the UiEvents it raised.
+# `Ui.messages` turns the Clicks among them into the game's own messages, read from
+# the `Clickable` nodes of that view. Same
 # button rules as PureScene: Down captures the pressed id; while captured only
 # that id gets Enter/Exit; Up releases (Click only when still over it).
@@ -93,13 +95,25 @@ primitive Ui =
     false
   # A tagged, translated rectangle with a label whose colour follows the state.
+  # The messages of the Clickables that `events` clicked, in order, read from `view`.
+  fun messages(view: SceneNode[M], events: List[UiEvent]) -> List[M] = match events
+    Nil => Nil
+    Cons(e, rest) =>
+      later := Ui.messages(view, rest)
+      if e.kind != Click
+        return later
+      if m := view.msgOf(e.id)
+        return Cons(head: m, tail: later)
+      later
+  # A button that sends `msg` when clicked; `id` identifies it for hover and press.
-  fun button(id: Int, label: Str, x: Float, y: Float, w: Float, h: Float, ui: UiState) -> SceneNode =
+  fun button(id: Int, msg: M, label: Str, x: Float, y: Float, w: Float, h: Float, ui: UiState) -> SceneNode[M] =
     color := uiIdleColor()
     if Ui.pressed(ui, id)
       color = uiPressedColor()
     else if Ui.hovered(ui, id)
       color = uiHoverColor()
-    Tagged(id: id, child: Group(transform: Translate(dx: x, dy: y), children: List(
+    Clickable(id: id, msg: msg, child: Group(transform: Translate(dx: x, dy: y), children: List(
       RectShape(x: 0.0, y: 0.0, w: w, h: h, color: color),
       Text(text: label, x: 4.0, y: 4.0, size: h * 0.5, color: Color.White))))
@@ -126,8 +140,8 @@ fun uiCount(s: UiStep, k: UiKind) -> Int =
 fun uiIs(e: UiEvent, id: Int, kind: UiKind) -> Bool = e.id == id && e.kind == kind
-fun uiButtonColor(n: SceneNode) -> Color = match n
+fun uiButtonColor(n: SceneNode[Int]) -> Color = match n
-  Tagged(_, child) => uiButtonColor(child)
+  Clickable(_, _, child) => uiButtonColor(child)
   Group(_, children) => uiButtonColor(children.at(0))
   RectShape(_, _, _, _, c) => c
   _ => Color.Black
@@ -186,9 +200,9 @@ test "hover_without_press_routes_move"
   assert !Ui.hovered(s3.ui, 5)
 test "button_visual_reflects_state"
-  idle := Ui.button(3, "Go", 10.0, 20.0, 100.0, 40.0, Ui.init())
+  idle := Ui.button(3, 30, "Go", 10.0, 20.0, 100.0, 40.0, Ui.init())
-  hov := Ui.button(3, "Go", 10.0, 20.0, 100.0, 40.0, Ui.step(Ui.init(), uiMove(1.0), 3).ui)
+  hov := Ui.button(3, 30, "Go", 10.0, 20.0, 100.0, 40.0, Ui.step(Ui.init(), uiMove(1.0), 3).ui)
-  prs := Ui.button(3, "Go", 10.0, 20.0, 100.0, 40.0, Ui.step(Ui.init(), uiDown(1.0), 3).ui)
+  prs := Ui.button(3, 30, "Go", 10.0, 20.0, 100.0, 40.0, Ui.step(Ui.init(), uiDown(1.0), 3).ui)
   assert uiButtonColor(idle).eq(uiIdleColor())
   assert uiButtonColor(hov).eq(uiHoverColor())
   assert uiButtonColor(prs).eq(uiPressedColor())
@@ -196,3 +210,11 @@ test "button_visual_reflects_state"
     assert hid == 3
   else
     assert false
+test "messages_are_the_clicked_buttons_messages"
+  view := Group(transform: Identity, children: List(Ui.button(3, 30, "Go", 0.0, 0.0, 10.0, 10.0, Ui.init()), Ui.button(4, 40, "Stop", 20.0, 0.0, 10.0, 10.0, Ui.init())))
+  evs := List(UiEvent(id: 4, kind: Press), UiEvent(id: 4, kind: Click), UiEvent(id: 9, kind: Click), UiEvent(id: 3, kind: Click))
+  ms := Ui.messages(view, evs)
+  assert ms.length() == 2
+  assert {ms.get(0) ?: -1} == 40
+  assert {ms.get(1) ?: -1} == 30