anchor.diff:      // seq<'T> * ('T -> M<'U>) -> M<'U>
       // or
       // seq<'T> * ('T -> M<'U>) -> seq<M<'U>>
  -    member this.For (sequence : seq<_>, body : 'T -> StatefulChoiceFuncClamped<_,_,_>)
  -        : StatefulChoiceFuncClamped<'State, _, 'Error> =
  +    member this.For (sequence : seq<_>, body : 'T -> StatefulChoiceFunc<_,_,_>)
  +        : StatefulChoiceFunc<'State, _, 'Error> =
           this.Using (sequence.GetEnumerator (),
               (fun enum ->
                   this.While (
  
positive.code: type ReaderProtectedStateBuilder () =
      // 'T -> M<'T>
      member __.Return value
          : ReaderProtectedStateFuncClamped<'Env, 'State, 'T, 'Error> =
          fun env state ->
          Choice1Of2 (value, state)
  
      // M<'T> -> M<'T>
      member __.ReturnFrom func
          : ReaderProtectedStateFunc<'Env, 'S1, 'S2, 'T, 'Error> =
          func
  
      // unit -> M<'T>
      member this.Zero ()
          : ReaderProtectedStateFuncClamped<'Env, 'State, unit, 'Error> =
          fun env state ->
          Choice1Of2 ((), state)
  
      // (unit -> M<'T>) -> M<'T>
      member this.Delay (f : unit -> ReaderProtectedStateFunc<_,_,_,_,_>)
          : ReaderProtectedStateFunc<'Env, 'S1, 'S2, 'T, 'Error> =
          fun env state -> f () env state
  
      // M<'T> * ('T -> M<'U>) -> M<'U>
      member __.Bind (m : ReaderProtectedStateFunc<_,_,'S2,_,_>, k : 'T -> ReaderProtectedStateFunc<_,_,_,_,_>)
          : ReaderProtectedStateFunc<'Env, 'S1, 'S3, 'U, 'Error> =
          fun env state ->
          match m env state with
          | Choice2Of2 error ->
  
negative.code:                     r2 state cont
  
      // M<'T> -> M<'T> -> M<'T>
      member inline __.TryWith (body : ProtectedStateContinuationFuncIndexed<_,_,_,_,_>, handler : exn -> ProtectedStateContinuationFuncIndexed<_,_,_,_,_>)
          : ProtectedStateContinuationFuncIndexed<'S1, 'S2, 'T, 'Error, 'K> =
          fun state cont ->
              try body state cont
              with ex ->
                  handler ex state cont
  
      // M<'T> -> M<'T> -> M<'T>
      member inline __.TryFinally (body : ProtectedStateContinuationFuncIndexed<_,_,_,_,_>, handler)
          : ProtectedStateContinuationFuncIndexed<'S1, 'S2, 'T, 'Error, 'K> =
          fun state cont ->
              try body state cont
              finally
                  handler ()
  
      // 'T * ('T -> M<'U>) -> M<'U> when 'U :> IDisposable
      member this.Using (resource : ('T :> System.IDisposable), body : 'T -> ProtectedStateContinuationFuncIndexed<_,_,_,_,_>)
          : ProtectedStateContinuationFuncIndexed<'S1, 'S2, 'U, 'Error, 'K> =
          this.TryFinally (body resource, (fun () ->
              if not <| isNull (box resource) then
                  resource.Dispose ()))
  
      // (unit -> bool) * M<'T> -> M<'T>
      member this.While (guard, body : ProtectedStateContinuationFunc<_,_,_,_>)
          : ProtectedStateContinuationFunc<'State, unit, 'Error, 'K> =
          if guard () then
              this.Bind (body, (fun () -> this.While (guard, body)))
          else
  