Querying and Observers

Two-state traffic light: the can_send response flips as the current state changes.

// Feature: `.can_send(event)` — check applicability without firing
// Syntax: returns true if the event would cause a transition from
// the current state, false otherwise.
// When to use: enable/disable UI buttons, validate input before
// committing, write tests that assert protocol invariants.

machine Light {
  state Red, Green
  initial Red
  Red -> Green on go
  Green -> Red on stop
}

let l = Light.new()

// In Red, "go" is valid but "stop" is not.
print(l.can_send("go"))  // expected: true
print(l.can_send("stop"))  // expected: false

l.send("go")

// In Green, the answer flips.
print(l.can_send("go"))  // expected: false
print(l.can_send("stop"))  // expected: true

Counter A → B → C with an observer that prints each step as from -> to via event.

// Feature: `.on_transition(callback)` — observe every transition
// Syntax: register a closure receiving `(from, to, event)`. Fires
// after each successful transition, in registration order.
// When to use: audit logs, metrics, replay/journaling, debugging
// — all the cross-cutting concerns that don't belong inside the
// machine definition.

machine Counter {
  state A, B, C
  initial A
  A -> B on next
  B -> C on next
  C -> A on reset
}

let c = Counter.new()

c.on_transition(|from, to, event| {
  print("{from} -> {to} via {event}")
})

c.send("next")

// expected: A -> B via next

c.send("next")

// expected: B -> C via next

c.send("reset")
// expected: C -> A via reset