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>
28 lines
1.0 KiB
FSharp
28 lines
1.0 KiB
FSharp
/// m04 state (optional, Exercise 4.7): the general pattern behind Random. A `State<'s, 'a>` wraps a function
|
|
/// `s -> (value, nextS)`: it reads a state, produces a value and hands on a new state. `Random<'a>` is
|
|
/// `State<uint32, 'a>`. Nothing in the game uses this file; it is here to show that Random was one example of a bigger idea.
|
|
module Snake.State
|
|
|
|
type State<'s, 'a> = State of ('s -> 'a * 's)
|
|
|
|
let run (s: 's) (State f: State<'s, 'a>) : 'a * 's = f s
|
|
|
|
let pure (a: 'a) : State<'s, 'a> = State(fun s -> (a, s))
|
|
|
|
let map (f: 'a -> 'b) (st: State<'s, 'a>) : State<'s, 'b> =
|
|
State(fun s ->
|
|
let a, next = run s st
|
|
(f a, next))
|
|
|
|
let bind (f: 'a -> State<'s, 'b>) (st: State<'s, 'a>) : State<'s, 'b> =
|
|
State(fun s ->
|
|
let a, next = run s st
|
|
run next (f a))
|
|
|
|
// A function of unit: a generic module-level value is not allowed in F#.
|
|
let get () : State<'s, 's> = State(fun s -> (s, s))
|
|
|
|
let put (s: 's) : State<'s, unit> = State(fun _ -> ((), s))
|
|
|
|
let modify (f: 's -> 's) : State<'s, unit> = State(fun s -> ((), f s))
|