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>
90 lines
3.2 KiB
FSharp
90 lines
3.2 KiB
FSharp
/// 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`
|
|
module Snake.IO
|
|
|
|
open Snake.View
|
|
|
|
/// An operation an IO program can ask the outside world to perform.
|
|
type Op =
|
|
| Draw of Shape
|
|
| RandomSeed
|
|
// m10: the stored best score, read and written.
|
|
| LoadBest
|
|
| SaveBest of int
|
|
|
|
/// What the outside world answers: `Done` for a `Draw` or a `SaveBest`, `Seed value` for a `RandomSeed`,
|
|
/// `Best value` for a `LoadBest`.
|
|
type OpResult =
|
|
| Done
|
|
| Seed of uint32
|
|
| Best of int
|
|
|
|
type IO<'a> =
|
|
| Pure of 'a
|
|
| Effect of Op * (OpResult -> IO<'a>)
|
|
|
|
/// The result of `trace`: the final value and the operations performed, in execution order.
|
|
type Traced<'a> = { Result: 'a; Ops: Op list }
|
|
|
|
let pure (a: 'a) : IO<'a> = Pure a
|
|
|
|
let effect (op: Op) : IO<OpResult> = Effect(op, pure)
|
|
|
|
// 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.
|
|
let rec bind (f: 'a -> IO<'b>) (io: IO<'a>) : IO<'b> =
|
|
match io with
|
|
| Pure a -> f a
|
|
| Effect(op, k) -> Effect(op, fun result -> bind f (k result))
|
|
|
|
let map (f: 'a -> 'b) (io: IO<'a>) : IO<'b> = bind (fun a -> Pure(f a)) io
|
|
|
|
let sequence (ios: IO<unit> list) : IO<unit> =
|
|
List.foldBack (fun io rest -> bind (fun () -> rest) io) ios (pure ())
|
|
|
|
let draw (shape: Shape) : IO<unit> = effect (Draw shape) |> map ignore
|
|
|
|
// A function of unit: F# evaluates module-level values as soon as the module is used, and a description
|
|
// is cheap to rebuild. An interpreter that answers a RandomSeed with anything but a Seed is broken; say so loudly.
|
|
let randomSeed () : IO<uint32> =
|
|
effect RandomSeed
|
|
|> map (fun result ->
|
|
match result with
|
|
| Seed value -> value
|
|
| _ -> failwith "RandomSeed must be answered with a Seed")
|
|
|
|
let drawScene (scene: Scene) : IO<unit> = sequence (List.map draw scene)
|
|
|
|
// m10: the stored best score. Reading it answers a number (built like randomSeed); saving answers Done, like a draw.
|
|
let loadBest () : IO<int> =
|
|
effect LoadBest
|
|
|> map (fun result ->
|
|
match result with
|
|
| Best value -> value
|
|
| _ -> failwith "LoadBest must be answered with a Best")
|
|
|
|
let saveBest (score: int) : IO<unit> = effect (SaveBest score) |> map ignore
|
|
|
|
// 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.
|
|
let traceWith (seed: uint32) (best: int) (io: IO<'a>) : Traced<'a> =
|
|
let rec go io performed =
|
|
match io with
|
|
| Pure a -> { Result = a; Ops = List.rev performed }
|
|
| Effect(op, k) ->
|
|
let answer =
|
|
match op with
|
|
| RandomSeed -> Seed seed
|
|
| LoadBest -> Best best
|
|
| Draw _
|
|
| SaveBest _ -> Done
|
|
|
|
go (k answer) (op :: performed)
|
|
|
|
go io []
|
|
|
|
// The Module 7 interpreter is the "no stored best" case.
|
|
let trace (seed: uint32) (io: IO<'a>) : Traced<'a> = traceWith seed 0 io
|