feat(fsharp): m07 io and m08 stream with tests

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

fsharp/solutions/Stream.fs

@@ -0,0 +1,81 @@
+/// m08 stream: an event stream is a pure automaton (a Mealy machine).
+/// There is no hidden state: whatever a stream "remembers" lives in the next stream it returns.
+module Snake.Stream
+
+/// Something that happens to the program: time passing (ms since start) or a key going down or up.
+type Event =
+    | Time of int64
+    | KeyDown of string
+    | KeyUp of string
+
+type Stream<'a> = Stream of (Event -> 'a list * Stream<'a>)
+
+let step (e: Event) (Stream f: Stream<'a>) : 'a list * Stream<'a> = f e
+
+// Sources remember nothing, so the next stream is the same source again.
+let keyDowns: Stream<string> =
+    let rec source () =
+        Stream(fun e ->
+            match e with
+            | KeyDown key -> [ key ], source ()
+            | _ -> [], source ())
+
+    source ()
+
+let keyUps: Stream<string> =
+    let rec source () =
+        Stream(fun e ->
+            match e with
+            | KeyUp key -> [ key ], source ()
+            | _ -> [], source ())
+
+    source ()
+
+// `last` is the time of the previous Time event. Multiples of ms in (last, t] fire, ascending.
+let rec private intervalFrom (ms: int64) (last: int64) : Stream<int64> =
+    Stream(fun e ->
+        match e with
+        | Time t -> [ for k in last / ms + 1L .. t / ms -> k * ms ], intervalFrom ms t
+        | _ -> [], intervalFrom ms last)
+
+let interval (ms: int64) : Stream<int64> = intervalFrom ms 0L
+
+// Each combinator steps the stream and wraps the *next* stream in the same combinator.
+let rec map (f: 'a -> 'b) (s: Stream<'a>) : Stream<'b> =
+    Stream(fun e ->
+        let out, next = step e s
+        List.map f out, map f next)
+
+let rec filter (p: 'a -> bool) (s: Stream<'a>) : Stream<'a> =
+    Stream(fun e ->
+        let out, next = step e s
+        List.filter p out, filter p next)
+
+let rec choose (f: 'a -> 'b option) (s: Stream<'a>) : Stream<'b> =
+    Stream(fun e ->
+        let out, next = step e s
+        List.choose f out, choose f next)
+
+let rec merge (a: Stream<'a>) (b: Stream<'a>) : Stream<'a> =
+    Stream(fun e ->
+        let outA, nextA = step e a
+        let outB, nextB = step e b
+        outA @ outB, merge nextA nextB)
+
+// The accumulator travels in the argument of the next scan, not in a variable.
+// List.scan keeps z as its first element; drop it, we only emit new accumulators.
+let rec scan (f: 'b -> 'a -> 'b) (z: 'b) (s: Stream<'a>) : Stream<'b> =
+    Stream(fun e ->
+        let out, next = step e s
+        let accs = List.tail (List.scan f z out)
+        accs, scan f (List.fold f z out) next)
+
+// Only the first step is special; afterwards we are just `next`.
+let startWith (v: 'a) (s: Stream<'a>) : Stream<'a> =
+    Stream(fun e ->
+        let out, next = step e s
+        v :: out, next)
+
+// mapFold threads the stream through the events like fold, and keeps each step's outputs.
+let run (events: Event list) (s: Stream<'a>) : 'a list =
+    List.mapFold (fun stream e -> step e stream) s events |> fst |> List.concat