anchor.diff:  /// <summary>
   /// </summary>
   [<Sealed>]
  -type StateBuilder () =
  +type IndexedStateBuilder () =
       // 'T -> M<'T>
       member inline __.Return (x)
  -        : StateFuncIndexed<'State, 'State, 'T> =
  +        : IndexedStateFunc<'State, 'State, 'T> =
           fun state ->
           x, state
   
       // M<'T> -> M<'T>
       member inline __.ReturnFrom func
  -        : StateFuncIndexed<'S1, 'S2, 'T> =
  +        : IndexedStateFunc<'S1, 'S2, 'T> =
           func
   
       // unit -> M<'T>
       member inline this.Zero ()
  -        : StateFuncIndexed<'State, 'State, unit> =
  +        : IndexedStateFunc<'State, 'State, unit> =
           this.Return ()
   
       // M<'T> * ('T -> M<'U>) -> M<'U>
  -    member inline __.Bind (m : StateFuncIndexed<_,'S2,'T>, k : 'T -> StateFuncIndexed<_,_,_>)
  -        : StateFuncIndexed<'S1, 'S3, 'U> =
  +    member inline __.Bind (m : IndexedStateFunc<_,'S2,'T>, k : 'T -> IndexedStateFunc<_,_,_>)
  +        : IndexedStateFunc<'S1, 'S3, 'U> =
           fun state ->
               let result, state = m state
               (k result) state
   
       // (unit -> M<'T>) -> M<'T>
  -    member inline this.Delay (f : unit -> StateFuncIndexed<_,_,_>)
  -        : StateFuncIndexed<'S1, 'S2, 'T> =
  +    member inline this.Delay (f : unit -> IndexedStateFunc<_,_,_>)
  +        : IndexedStateFunc<'S1, 'S2, 'T> =
           this.Bind (this.Return (), f)
   
       // M<'T> -> M<'T> -> M<'T>
       // or
       // M<unit> -> M<'T> -> M<'T>
  -    member inline this.Combine (r1 : StateFuncIndexed<_,'S2,_>, r2 : StateFuncIndexed<_,_,_>)
  -        : StateFuncIndexed<'S1, 'S3, 'T> =
  +    member inline this.Combine (r1 : IndexedStateFunc<_,'S2,_>, r2 : IndexedStateFunc<_,_,_>)
  +        : IndexedStateFunc<'S1, 'S3, 'T> =
           this.Bind (r1, fun () -> r2)
   
       // M<'T> -> M<'T> -> M<'T>
  -    member inline __.TryWith (body : StateFuncIndexed<_,_,_>, handler : exn -> StateFuncIndexed<_,_,_>)
  -        : StateFuncIndexed<'S1, 'S2, 'T> =
  +    member inline __.TryWith (body : IndexedStateFunc<_,_,_>, handler : exn -> IndexedStateFunc<_,_,_>)
  +        : IndexedStateFunc<'S1, 'S2, 'T> =
           fun state ->
               try body state
               with ex ->
                   handler ex state
   
       // M<'T> -> M<'T> -> M<'T>
  -    member inline __.TryFinally (body : StateFuncIndexed<_,_,_>, handler)
  -        : StateFuncIndexed<'S1, 'S2, 'T> =
  +    member inline __.TryFinally (body : IndexedStateFunc<_,_,_>, handler)
  +        : IndexedStateFunc<'S1, 'S2, 'T> =
           fun state ->
               try body state
               finally
                   handler ()
   
       // 'T * ('T -> M<'U>) -> M<'U> when 'U :> IDisposable
  -    member inline this.Using (resource : ('T :> System.IDisposable), body : 'T -> StateFuncIndexed<_,_,_>)
  -        : StateFuncIndexed<'S1, 'S2, 'U> =
  +    member inline this.Using (resource : ('T :> System.IDisposable), body : 'T -> IndexedStateFunc<_,_,_>)
  +        : IndexedStateFunc<'S1, 'S2, '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 : StateFuncIndexed<_,_,_>)
  -        : StateFuncIndexed<'State, 'State, unit> =
  +    member this.While (guard, body : IndexedStateFunc<_,_,_>)
  +        : IndexedStateFunc<'State, 'State, unit> =
           if guard () then
               this.Bind (body, (fun () -> this.While (guard, body)))
           else
  
positive.code: /// <summary>
  /// </summary>
  [<Sealed>]
  type ProtectedStateBuilder () =
      // 'T -> M<'T>
      member __.Return value
          : ProtectedStateFuncIndexed<'State, 'State, 'T, 'Error> =
          fun state ->
          Choice1Of2 (value, state)
  
      // M<'T> -> M<'T>
      member __.ReturnFrom func
          : ProtectedStateFuncIndexed<'S1, 'S2, 'T, 'Error> =
          func
  
      // unit -> M<'T>
      member this.Zero ()
          : ProtectedStateFuncIndexed<'State, 'State, unit, 'Error> =
          fun state ->
          Choice1Of2 ((), state)
  
      // (unit -> M<'T>) -> M<'T>
      member this.Delay (f : unit -> ProtectedStateFuncIndexed<_,_,_,_>)
          : ProtectedStateFuncIndexed<'S1, 'S2, 'T, 'Error> =
          fun state -> f () state
  
      // M<'T> * ('T -> M<'U>) -> M<'U>
      member __.Bind (m : ProtectedStateFuncIndexed<_,'S2,_,_>, k : 'T -> ProtectedStateFuncIndexed<_,_,_,_>)
          : ProtectedStateFuncIndexed<'S1, 'S3, 'U, 'Error> =
          fun state ->
          match m state with
          | Choice2Of2 error ->
  
negative.code: /// <summary>
  /// </summary>
  [<Sealed>]
  type ReaderProtectedIndexedStateBuilder () =
      // 'T -> M<'T>
      member __.Return value
          : ReaderProtectedIndexedStateFunc<'Env, 'State, 'State, 'T, 'Error> =
          fun env state ->
          Choice1Of2 (value, state)
  
      // M<'T> -> M<'T>
      member __.ReturnFrom func
          : ReaderProtectedIndexedStateFunc<'Env, 'S1, 'S2, 'T, 'Error> =
          func
  
      // unit -> M<'T>
      member this.Zero ()
          : ReaderProtectedIndexedStateFunc<'Env, 'State, 'State, unit, 'Error> =
          fun env state ->
          Choice1Of2 ((), state)
  
      // (unit -> M<'T>) -> M<'T>
      member this.Delay (f : unit -> ReaderProtectedIndexedStateFunc<_,_,_,_,_>)
          : ReaderProtectedIndexedStateFunc<'Env, 'S1, 'S2, 'T, 'Error> =
          fun env state -> f () env state
  
      // M<'T> * ('T -> M<'U>) -> M<'U>
      member __.Bind (m : ReaderProtectedIndexedStateFunc<_,_,'S2,_,_>, k : 'T -> ReaderProtectedIndexedStateFunc<_,_,_,_,_>)
          : ReaderProtectedIndexedStateFunc<'Env, 'S1, 'S3, 'U, 'Error> =
          fun env state ->
          match m env state with
          | Choice2Of2 error ->
  