anchor.diff:          asyncChoice
   
       // unit -> M<'T>
  -    member (*inline*) __.Zero () : Async<Choice<unit, 'Error>> =
  -        Choice1Of2 ()
  -        |> async.Return
  +    member inline this.Zero () : Async<Choice<unit, 'Error>> =
  +        this.Return ()
   
       // (unit -> M<'T>) -> M<'T>
  -    member __.Delay (f : unit -> Async<Choice<'T, 'Error>>) : Async<Choice<'T, 'Error>> =
  -        f ()
  +    member inline this.Delay (generator : unit -> Async<Choice<'T, 'Error>>) : Async<Choice<'T, 'Error>> =
  +        async.Delay generator
   
       // M<'T> -> M<'T> -> M<'T>
       // or
  
positive.code:             finally
                  handler ()
  
      // 'T * ('T -> M<'U>) -> M<'U> when 'U :> IDisposable
      member (*inline*) this.Using (resource : ('T :> System.IDisposable), body : 'T -> Lazy<_>)
          : Lazy<'U> =
          this.TryFinally (body resource, (fun () ->
              if not <| isNull (box resource) then
                  resource.Dispose ()))
  
      // (unit -> bool) * M<'T> -> M<'T>
      member this.While (guard, body : Lazy<_>)
  
negative.code:         func
  
      // unit -> M<'T>
      member inline this.Zero ()
          : AsyncProtectedStateFunc<'State, unit, 'Error> =
          this.Return ()
  
      // (unit -> M<'T>) -> M<'T>
      member this.Delay (generator : unit -> AsyncProtectedStateFunc<_,_,_>)
          : AsyncProtectedStateFunc<'State, 'T, 'Error> =
          fun state -> generator () state
  
      // M<'T> * ('T -> M<'U>) -> M<'U>
      member __.Bind (m : AsyncProtectedStateFunc<_,_,_>, k : 'T -> AsyncProtectedStateFunc<_,_,_>)
  