anchor.diff:    let eval m s = m s |> fst
     let exec m s = m s |> snd
     let empty = fun s -> ((), s)
  +  let bind k m = fun s -> let (a, s') = m s in (k a) s'
     
     /// The state monad.
     /// The algorithm is adjusted from my original work off of Brian Beckman's http://channel9.msdn.com/shows/Going+Deep/Brian-Beckman-The-Zen-of-Expressing-State-The-State-Monad/.
  
positive.code: module Reader =
  
    type Reader<'r,'a> = 'r -> 'a
    
    /// The reader monad.
    /// This monad comes from Matthew Podwysocki's http://codebetter.com/blogs/matthew.podwysocki/archive/2010/01/07/much-ado-about-monads-reader-edition.aspx.
  
negative.code:   let throw exn : Cont<'a,'r> = fun cont econt -> econt exn
    let callCC (f: ('a -> Cont<'b,'r>) -> Cont<'a,'r>) : Cont<'a,'r> =
      fun cont econt -> runCont (f (fun a -> (fun _ _ -> cont a))) cont econt
    let bind f comp1 = 
      fun cont econt ->
        runCont comp1 (fun a -> protect f a (fun comp2 -> runCont comp2 cont econt) econt) econt   
  
    type ContinuationBuilder() =
      member this.Return(a) : Cont<_,_> = fun cont econt -> cont a
      member this.ReturnFrom(comp:Cont<_,_>) = comp
      member this.Bind(comp1, f) = bind f comp1
      member this.Catch(comp:Cont<_,_>) : Cont<Choice<_, exn>, _> = fun cont econt ->
        runCont comp (fun v -> cont (Choice1Of2 v)) (fun err -> cont (Choice2Of2 err))
      member this.Zero() =
  