/// 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))