anchor.diff:  module Reader =
   
     type Reader<'r,'a> = 'r -> 'a
  +
  +  let bind k m = fun r -> (k (m r)) r
     
     /// 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.
  
positive.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
     
    type ContinuationBuilder() =
      member this.Return(a) : Cont<_,_> = fun cont econt -> cont a
      member this.ReturnFrom(comp:Cont<_,_>) = comp
      member this.Bind(comp1, f) = fun cont econt ->
        runCont comp1 (fun a -> protect f a (fun comp2 -> runCont comp2 cont econt) econt) econt
      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() =
  
negative.code:     member this.Return(a) : Reader<'r,'a> = fun _ -> a
      member this.ReturnFrom(a:Reader<'r,'a>) = a
      member this.Bind(m:Reader<'r,'a>, k:'a -> Reader<'r,'b>) : Reader<'r,'b> =
        bind k m
      member this.Zero() = this.Return ()
      member this.Combine(r1, r2) = this.Bind(r1, fun () -> r2)
      member this.TryWith(m:Reader<'r,'a>, h:exn -> Reader<'r,'a>) : Reader<'r,'a> =
  