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>
58 lines
2.2 KiB
FSharp
58 lines
2.2 KiB
FSharp
/// m09 runtime: the single impure place in the course (with the web/ glue); everything else only builds values.
|
|
/// Here we interpret IO descriptions against a Platform and hold the one mutable variable, the current stream.
|
|
module Snake.Runtime
|
|
|
|
open Snake.View
|
|
open Snake.IO
|
|
open Snake.Stream
|
|
|
|
/// The outside world, as the runtime sees it.
|
|
type Platform =
|
|
{ FillRect: int -> int -> int -> int -> string -> unit
|
|
FillText: int -> int -> string -> string -> int -> string -> unit
|
|
RandomSeed: unit -> uint32
|
|
// m10: the stored best score; reading must never fail (anything unreadable is 0).
|
|
LoadBest: unit -> int
|
|
SaveBest: int -> unit
|
|
StartClock: (int64 -> unit) -> unit
|
|
OnKeyDown: (string -> unit) -> unit
|
|
OnKeyUp: (string -> unit) -> unit
|
|
// m13: clicks on the canvas, in canvas pixels.
|
|
OnClick: (int -> int -> unit) -> unit }
|
|
|
|
// Perform one op on the platform and return its answer.
|
|
let private perform (p: Platform) (op: Op) : OpResult =
|
|
match op with
|
|
| RandomSeed -> Seed(p.RandomSeed())
|
|
| LoadBest -> Best(p.LoadBest())
|
|
| SaveBest score ->
|
|
p.SaveBest score
|
|
Done
|
|
| Draw(Rect(x, y, w, h, color)) ->
|
|
p.FillRect x y w h color
|
|
Done
|
|
| Draw(Text(x, y, text, color, size, align)) ->
|
|
p.FillText x y text color size align
|
|
Done
|
|
|
|
// Tail recursive, so it compiles to a loop: a scene is hundreds of ops and the stack must not grow with them.
|
|
let rec runIO (p: Platform) (io: IO<'a>) : 'a =
|
|
match io with
|
|
| Pure a -> a
|
|
| Effect(op, k) -> runIO p (k (perform p op))
|
|
|
|
let runApp (p: Platform) (main: IO<Stream<IO<unit>>>) : unit =
|
|
// The one mutable variable. F# closures cannot capture a `let mutable`, so it is a ref cell.
|
|
let stream = ref (runIO p main)
|
|
|
|
let feed (event: Event) =
|
|
let ios, next = Stream.step event stream.Value
|
|
stream.Value <- next
|
|
List.iter (runIO p) ios
|
|
|
|
p.OnKeyDown(fun key -> feed (KeyDown key))
|
|
p.OnKeyUp(fun key -> feed (KeyUp key))
|
|
// m13: a fourth kind of event. Programs that do not listen for clicks simply ignore them.
|
|
p.OnClick(fun x y -> feed (Click(x, y)))
|
|
p.StartClock(fun t -> feed (Time t))
|