feat(fsharp): m09 input/app/runtime and m10 extensions with tests

Co-Authored-By: Claude Opus 5.5 <[email protected]>

fsharp/solutions/App.fs

@@ -0,0 +1,28 @@
+/// m09 app: the whole game wired together as values: streams of actions in, a stream of drawings out.
+module Snake.App
+
+open Snake.Model
+open Snake.IO
+open Snake.Stream
+
+let TICK_MS = 150L
+let FRAME_MS = 25L
+
+// Everything that can happen to the game: a Tick every TICK_MS, and an action for each bound key.
+let classicActions: Stream<Action> =
+    Stream.merge (Stream.interval TICK_MS |> Stream.map (fun _ -> Tick)) (Stream.keyDowns |> Stream.choose Input.keyToAction)
+
+// m10: a Frame every FRAME_MS instead of a Tick; the game itself decides (movesEvery) which frames take a step.
+let speedActions: Stream<Action> =
+    Stream.merge (Stream.interval FRAME_MS |> Stream.map (fun _ -> Frame)) (Stream.keyDowns |> Stream.choose Input.keyToAction)
+
+// Actions folded into game states. startWith puts the initial state first so it is drawn right away.
+let states (seed: uint32) (actions: Stream<Action>) : Stream<GameState> =
+    actions |> Stream.scan Game.update (Spawn.newGame seed) |> Stream.startWith (Spawn.newGame seed)
+
+let render (state: GameState) : IO<unit> = IO.drawScene (View.view state)
+
+// The whole program as a value: get a seed, then turn the stream of states into a stream of drawings.
+// Nothing runs here; Runtime interprets it.
+let main () : IO<Stream<IO<unit>>> =
+    IO.randomSeed () |> IO.map (fun seed -> states seed speedActions |> Stream.map render)

fsharp/solutions/Input.fs

@@ -0,0 +1,15 @@
+/// m09 input: from keyboard keys to game actions.
+module Snake.Input
+
+open Snake.Model
+
+// A match on string literals is the lookup table; `|` lists the alternatives.
+let keyToAction (key: string) : Action option =
+    match key with
+    | "ArrowUp" | "w" | "W" -> Some(Turn Up)
+    | "ArrowDown" | "s" | "S" -> Some(Turn Down)
+    | "ArrowLeft" | "a" | "A" -> Some(Turn Left)
+    | "ArrowRight" | "d" | "D" -> Some(Turn Right)
+    | " " -> Some TogglePause // m10
+    | "r" | "R" -> Some Restart // m10
+    | _ -> None

fsharp/solutions/Runtime.fs

@@ -0,0 +1,46 @@
+/// 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
+      StartClock: (int64 -> unit) -> unit
+      OnKeyDown: (string -> unit) -> unit
+      OnKeyUp: (string -> 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())
+    | 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))
+    p.StartClock(fun t -> feed (Time t))

fsharp/solutions/Snake.fsproj

@@ -15,5 +15,8 @@
     <Compile Include="View.fs" />
     <Compile Include="IO.fs" />
     <Compile Include="Stream.fs" />
+    <Compile Include="Input.fs" />
+    <Compile Include="App.fs" />
+    <Compile Include="Runtime.fs" />
   </ItemGroup>
 </Project>