Lucas WintherandClaude Fable 5.2
edd57f0148
Audit pass: - Frame rule counts frames since the last move, so every step lasts exactly movesEvery(score) frames, also right after a speed-up - clampTime + MAX_GAP_MS: a hidden tab no longer replays the whole gap - Pong Restart keeps held keys - Fact corrections (mulberry32 output coverage, Haskell IO, uniform) - New fixture cases from a mutation analysis Extensions (all three tracks, shared fixtures, course text): - Turn queue (Exercise 10.6), persisted high score (10.7), replay viewer (10.8), play() end-to-end helper (9.5) - Optional State (4.7) and optional Module 7b, stack-safe IO - Module 12, property-based testing with generators, shrinking, invariants and a model-based oracle - Module 13, Conway's Life with a Click event - JS type checking via jsconfig, JSDoc and types.d.ts - Maintainer tools: scripts/mutate.mjs, scripts/typecheck-js.sh, Playwright end-to-end suite (e2e/, scripts/e2e.sh) Docs: docs/contract.md is the canonical contract; specs and build log under docs/superpowers. Verified: JS 728, Scala 689, F# 691 unit tests; stubs and progression M01-M13 and M07b; 176 end-to-end tests on Chromium and WebKit. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
80 lines
3.0 KiB
Scala
80 lines
3.0 KiB
Scala
package snake
|
|
|
|
/** An operation an IO program can ask the outside world to perform. */
|
|
enum Op:
|
|
case Draw(shape: Shape)
|
|
case RandomSeed
|
|
case LoadBest // m10
|
|
case SaveBest(score: Int) // m10
|
|
|
|
/**
|
|
* What the outside world answers: `Done` for a `Draw`, `Seed(value)` for a `RandomSeed`;
|
|
* (m10) `Best(value)` for a `LoadBest` and `Done` for a `SaveBest`.
|
|
*/
|
|
enum OpResult:
|
|
case Done
|
|
case Seed(value: Long)
|
|
case Best(value: Int)
|
|
|
|
/**
|
|
* m07 io: effects as values. An IO is a plain-data description of a program; nothing runs until interpreted.
|
|
* - `Pure(a)` done, with a value
|
|
* - `Effect(op, k)` perform `op`, then continue with `k(result)`
|
|
*/
|
|
enum IO[+A]:
|
|
case Pure(a: A)
|
|
case Effect(op: Op, k: OpResult => IO[A])
|
|
|
|
def map[B](f: A => B): IO[B] = flatMap(a => IO.Pure(f(a)))
|
|
|
|
// Pure: apply f now. Effect: keep the op, and extend the continuation so f runs after k.
|
|
// Nothing is performed here, we only build a bigger description.
|
|
def flatMap[B](f: A => IO[B]): IO[B] = this match
|
|
case Pure(a) => f(a)
|
|
case Effect(op, k) => Effect(op, result => k(result).flatMap(f))
|
|
|
|
final case class Traced[A](result: A, ops: List[Op])
|
|
|
|
object IO:
|
|
|
|
def pure[A](a: A): IO[A] = Pure(a)
|
|
|
|
def effect(op: Op): IO[OpResult] = Effect(op, pure)
|
|
|
|
def sequence(ios: List[IO[Unit]]): IO[Unit] =
|
|
ios.foldRight(pure(()))((io, rest) => io.flatMap(_ => rest))
|
|
|
|
def draw(shape: Shape): IO[Unit] = effect(Op.Draw(shape)).map(_ => ())
|
|
|
|
// An interpreter that answers a RandomSeed with anything but a Seed is broken; say so loudly.
|
|
lazy val randomSeed: IO[Long] = effect(Op.RandomSeed).map {
|
|
case OpResult.Seed(value) => value
|
|
case other => throw new IllegalStateException(s"RandomSeed must be answered with a Seed, not $other")
|
|
}
|
|
|
|
def drawScene(scene: Scene): IO[Unit] = sequence(scene.map(draw))
|
|
|
|
// m10: the stored best score. Reading it answers a number; saving answers nothing, like a draw.
|
|
lazy val loadBest: IO[Int] = effect(Op.LoadBest).map {
|
|
case OpResult.Best(value) => value
|
|
case other => throw new IllegalStateException(s"LoadBest must be answered with a Best, not $other")
|
|
}
|
|
|
|
def saveBest(score: Int): IO[Unit] = effect(Op.SaveBest(score)).map(_ => ())
|
|
|
|
// Answer each op with a canned result, collecting the ops as we go. Tail recursion: the compiler turns it
|
|
// into a loop, so long programs cannot overflow the stack, and still nothing is mutated.
|
|
// `best` (m10) answers LoadBest, the way `seed` answers RandomSeed; it defaults to 0 so m07 calls stay valid.
|
|
def trace[A](io: IO[A], seed: Long, best: Int = 0): Traced[A] =
|
|
@annotation.tailrec
|
|
def go(io: IO[A], done: List[Op]): Traced[A] = io match
|
|
case Pure(a) => Traced(a, done.reverse)
|
|
case Effect(op, k) =>
|
|
val answer = op match
|
|
case Op.RandomSeed => OpResult.Seed(seed)
|
|
case Op.Draw(_) => OpResult.Done
|
|
case Op.LoadBest => OpResult.Best(best)
|
|
case Op.SaveBest(_) => OpResult.Done
|
|
go(k(answer), op :: done)
|
|
go(io, Nil)
|