anchor.diff:          this.Return ()
   
       // M<'T> * ('T -> M<'U>) -> M<'U>
  -    member __.Bind (m : ReaderStateFunc<_,_,_>, k : 'T -> ReaderStateFunc<_,_,_>)
  +    member __.Bind (m : ReaderStateFunc<_,_,_>, binder : 'T -> ReaderStateFunc<_,_,_>)
           : ReaderStateFunc<'Env, 'State, 'U> =
           fun env state ->
               let result, state = m env state
  -            (k result) env state
  +            (binder result) env state
   
       // (unit -> M<'T>) -> M<'T>
  -    member this.Delay (f : unit -> ReaderStateFunc<_,_,_>)
  +    member __.Delay (generator : unit -> ReaderStateFunc<_,_,_>)
           : ReaderStateFunc<'Env, 'State, 'T> =
  -        this.Bind (this.Return (), f)
  +        generator ()
   
       // M<'T> -> M<'T> -> M<'T>
       // or
  
positive.code:         | Choice2Of2 error ->
              return Choice2Of2 error
          | Choice1Of2 x ->
              return! f x
          }
  
      // M<'T> * (exn -> M<'T>) -> M<'T>
      member (*inline*) __.TryWith (body : 'T -> Async<Choice<'U, 'Error>>, handler) =
          fun value ->
              try body value
              with ex ->
                  handler ex
  
      // M<'T> * (unit -> unit) -> M<'T>
      member (*inline*) __.TryFinally (body : 'T -> Async<Choice<'U, 'Error>>, handler) =
          fun value ->
              try body value
              finally
                  handler ()
  
      // 'T * ('T -> M<'U>) -> M<'U> when 'U :> IDisposable
      member this.Using (resource : ('T :> System.IDisposable), body : _ -> Async<Choice<_,_>>)
          : Async<Choice<'U, 'Error>> =
          try body resource
          finally
              if not <| isNull (box resource) then
                  resource.Dispose ()
  
      // (unit -> bool) * M<'T> -> M<'T>
      member this.While (guard, body : Async<Choice<unit, 'Error>>) : Async<Choice<_,_>> =
  
negative.code:         fun _ -> Choice1Of2 ()
  
      // (unit -> M<'T>) -> M<'T>
      member __.Delay (generator : unit -> ReaderChoiceFunc<'Env, 'T, 'Error>)
          : ReaderChoiceFunc<'Env, 'T, 'Error> =
          generator ()
  
      // M<'T> * ('T -> M<'U>) -> M<'U>
      member __.Bind (f : ReaderChoiceFunc<_,_,_>, binder : 'T -> ReaderChoiceFunc<_,_,_>)
          : ReaderChoiceFunc<'Env, 'U, 'Error> =
          fun env ->
          match f env with
          | Choice2Of2 error ->
              Choice2Of2 error
          | Choice1Of2 result ->
              binder result env
  
      // M<'T> -> M<'T> -> M<'T>
      // or
  