wip(0.S1, 0.S2): state records, mut and read-only state parameters, entry injection, module var refused; ludic migrate state

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

examples/rejected/module_let_write.ludic

@@ -0,0 +1,8 @@
+# 0.S: a module-level let is immutable all the way down - a write through it is refused
+program ModuleLetWrite {
+  let LIMITS: []int = [1, 2]
+  entry {
+    LIMITS[0] = 3
+    print(LIMITS[0])
+  }
+}

examples/rejected/module_var.ludic

@@ -0,0 +1,7 @@
+# 0.S: a module-level var is refused - a module's changing data is its state
+program ModuleVar {
+  var count: int = 0
+  entry {
+    print(count)
+  }
+}

examples/rejected/mut_not_state.ludic

@@ -0,0 +1,7 @@
+# 0.S: `mut` is for a state parameter
+program MutNotState {
+  function f(x: mut int) -> int { return x }
+  entry {
+    print(f(1))
+  }
+}

examples/rejected/state_mut_arg.ludic

@@ -0,0 +1,9 @@
+# 0.S: a read-only state is not handed on where a mut one is wanted
+program StateMutArg {
+  state Tally { n: int = 0 }
+  function bump(c: mut Tally) -> void { c.n += 1 }
+  function look(c: Tally) -> void { bump(c) }
+  entry (c: Tally) {
+    look(c)
+  }
+}

examples/rejected/state_readonly.ludic

@@ -0,0 +1,11 @@
+# 0.S: a state taken without `mut` is read-only - assigning through it is refused
+program StateReadonly {
+  state Tally { n: int = 0 }
+  function peek(c: Tally) -> int {
+    c.n = 1
+    return c.n
+  }
+  entry (c: Tally) {
+    print(peek(c))
+  }
+}

examples/state/counter.ludic

@@ -0,0 +1,29 @@
+# counter.ludic — 0.S: no function writes a global. The changing data is a `state`; it reaches a
+# function only as a parameter - `c: mut Tally` to change it, `c: Tally` to read it - and the
+# runtime supplies it where the program is entered: `entry (c: mut Tally)`, an `@On` listener's
+# `(c: mut Tally)`, and any function value (`fn tick` is tick with its Tally supplied).
+#
+# Running it prints:  11 3 heard 5
+program Counter {
+  state Tally {
+    n: int = 0
+    heard: int = 0
+    runs: []int = null
+  }
+  event Ping { amount: int }
+  @On(Ping) handler Heard(c: mut Tally) { c.heard += amount }
+  function bump(c: mut Tally, by: int) -> void {
+    c.n = c.n + by
+    if c.runs == null { c.runs = new []int }
+    push(c.runs, by)
+  }
+  function total(c: Tally) -> int { return c.n }
+  function tick(c: mut Tally, by: int) -> void { bump(c, by) }
+  function run_later(f: fn(int) -> void, by: int) -> void { f(by) }
+  entry (c: mut Tally) {
+    bump(c, 3)
+    run_later(fn tick, 8)
+    emit Ping(amount: 5)
+    print(`{total(c)} {len(c.runs) + 1} heard {c.heard}`)
+  }
+}

examples/state/port_field.ludic

@@ -0,0 +1,12 @@
+# port_field.ludic — 0.S: a port member bound to a state's field, `money: Wallet.cash` - read
+# through the Wallet the runtime supplies, so a port needs no wrapper and no global.
+#
+# Running it prints:  40
+program PortField {
+  state Wallet { cash: int = 40 }
+  port Purse { money: fn() -> int }
+  bind Purse { money: Wallet.cash }
+  entry {
+    print(Purse.money())
+  }
+}

examples/state/tested.ludic

@@ -0,0 +1,14 @@
+# tested.ludic — 0.S: a test declares the states it uses, `test "name" (c: mut Tally)`, and gets a
+# fresh one (each test is a process of its own). Its runner prints:
+#   == 2 passed, 0 failed ==
+program Tested {
+  state Tally { n: int = 0 }
+  function bump(c: mut Tally) -> void { c.n += 1 }
+  test "a bump counts one" (c: mut Tally) {
+    bump(c)
+    expect_eq(c.n, 1)
+  }
+  test "reading needs no mut" (c: Tally) {
+    expect_eq(c.n, 0)
+  }
+}