47 lines
1.7 KiB
FSharp
47 lines
1.7 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
|
|
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))
|