anchor.diff:                      body enum.Current)))
   
   
  -//
  +/// <summary>
  +/// </summary>
   [<Sealed>]
   type StateContinuationBuilder () =
       // 'T -> M<'T>
  -    member __.Return value
  +    member inline __.Return value
           : StateContinuationFuncClamped<'State, 'T, 'K> =
           fun state cont ->
               cont (value, state)
   
       // M<'T> -> M<'T>
  -    member __.ReturnFrom func
  +    member inline __.ReturnFrom func
           : StateContinuationFunc<'S1, 'S2, 'T, 'K> =
           func
   
       // unit -> M<'T>
  -    member __.Zero ()
  +    member inline __.Zero ()
           : StateContinuationFuncClamped<'State, unit, 'K> =
           fun state cont ->
               cont ((), state)
   
  +    // (unit -> M<'T>) -> M<'T>
  +    member __.Delay f
  +        : StateContinuationFunc<'S1, 'S2, 'T, 'K> =
  +        f ()
  +
       // M<'T> * ('T -> M<'U>) -> M<'U>
  -    member __.Bind (m : StateContinuationFunc<_,'S2,_,_>, k : 'T -> StateContinuationFunc<_,_,_,_>)
  +    member inline __.Bind (m : StateContinuationFunc<_,'S2,_,_>, k : 'T -> StateContinuationFunc<_,_,_,_>)
           : StateContinuationFunc<'S1, 'S3, 'U, 'K> =
           fun state cont ->
               m state <| fun (result, state) ->
                   k result state cont
   
  -    // (unit -> M<'T>) -> M<'T>
  -    member __.Delay f
  -        : StateContinuationFunc<'S1, 'S2, 'T, 'K> =
  -        f ()
  -
       // M<'T> -> M<'T> -> M<'T>
       // or
       // M<unit> -> M<'T> -> M<'T>
  -    member __.Combine (r1 : StateContinuationFunc<_,_,_,_>, r2 : StateContinuationFunc<_,_,_,_>)
  +    member inline __.Combine (r1 : StateContinuationFunc<_,_,_,_>, r2 : StateContinuationFunc<_,_,_,_>)
           : StateContinuationFunc<_,_,_,_> =
           fun state cont ->
               r1 state <| fun ((), state) ->
                   r2 () state cont
   
       // M<'T> -> M<'T> -> M<'T>
  -    member __.TryWith (body : StateContinuationFunc<_,_,_,_>, handler : exn -> StateContinuationFunc<_,_,_,_>)
  +    member inline __.TryWith (body : StateContinuationFunc<_,_,_,_>, handler : exn -> StateContinuationFunc<_,_,_,_>)
           : StateContinuationFunc<_,_,_,_> =
           fun state cont ->
               try body state cont
  
positive.code:     let reader = ReaderBuilder ()
      //
      let readerState = ReaderStateBuilder ()
      //
      [<GeneralizableValue>]
      let writer<'Writer
          when 'Writer :> IWriter<'Writer>
  
negative.code: //                    body enum.Current)))
  
  
  /// <summary>
  /// </summary>
  [<Sealed>]
  type MaybeBuilder () =
      // 'T -> M<'T>
      member inline __.Return value : 'T option =
          Some value
  
      // M<'T> -> M<'T>
      member inline __.ReturnFrom value : 'T option =
          value
  
      // unit -> M<'T>
      member inline __.Zero () : unit option =
          Some ()     // TODO : Should this be None?
  
      // (unit -> M<'T>) -> M<'T>
      member __.Delay (f : unit -> 'T option) : 'T option =
          f ()
  
      // M<'T> -> M<'T> -> M<'T>
      // or
      // M<unit> -> M<'T> -> M<'T>
      member inline __.Combine (r1, r2 : 'T option) : 'T option =
          match r1 with
          | None ->
              None
          | Some () ->
              r2
  
      // M<'T> * ('T -> M<'U>) -> M<'U>
      member inline __.Bind (value, f : 'T -> 'U option) : 'U option =
          Option.bind f value
  
  //    // M<'T> -> M<'T> -> M<'T>
  //    member this.TryWith (body, handler) : _ option =
  //        notImpl "TryWith"
  //
  //    // M<'T> -> M<'T> -> M<'T>
  //    member this.TryFinally (body, handler) : _ option =
  //        notImpl "TryFinally"
  //
  //    // 'T * ('T -> M<'U>) -> M<'U> when 'U :> IDisposable
  //    member this.Using (resource : ('T :> System.IDisposable), body) : _ option =
  //        notImpl "Using"
  //
  //    // (unit -> bool) * M<'T> -> M<'T>
  //    member this.While (guard, body) : _ option =
  //        notImpl "While"
  //
  //    // seq<'T> * ('T -> M<'U>) -> M<'U>
  //    // or
  //    // seq<'T> * ('T -> M<'U>) -> seq<M<'U>>
  //    member this.For (sequence : seq<_>, body : 'T -> unit option) : _ option =
  //        notImpl "For"
  
  
  /// <summary>
  /// </summary>
  [<Sealed>]
  type ChoiceBuilder () =
      // 'T -> M<'T>
      member inline __.Return value : Choice<'T, 'Error> =
          Choice1Of2 value
  
      // M<'T> -> M<'T>
      member inline __.ReturnFrom (m : Choice<'T, 'Error>) =
          m
  
      // unit -> M<'T>
      member inline __.Zero () : Choice<unit, 'Error> =
          Choice1Of2 ()
  
      // (unit -> M<'T>) -> M<'T>
      member __.Delay (f : unit -> Choice<'T, 'Error>) : Choice<'T, 'Error> =
          f ()
  
      // M<'T> -> M<'T> -> M<'T>
      // or
      // M<unit> -> M<'T> -> M<'T>
      member inline __.Combine (r1, r2) : Choice<'T, 'Error> =
          match r1 with
          | Choice2Of2 error ->
              Choice2Of2 error
          | Choice1Of2 () ->
              r2
  
      // M<'T> * ('T -> M<'U>) -> M<'U>
      member inline __.Bind (value, f : 'T -> Choice<'U, 'Error>) : Choice<'U, 'Error> =
          match value with
          | Choice2Of2 error ->
              Choice2Of2 error
          | Choice1Of2 x ->
              f x
  
  //    // M<'T> -> M<'T> -> M<'T>
  //    member inline __.TryWith (body : 'T -> Choice<'U, 'Error>, handler) =
  //        fun value ->
  //            try body value
  //            with ex ->
  //                handler ex
  //
  //    // M<'T> -> M<'T> -> M<'T>
  //    member inline __.TryFinally (body : 'T -> 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 : _ -> Choice<_,_>)
  