anchor.diff:  /// <summary>
   /// </summary>
   [<Sealed>]
  -type ReaderStateBuilder () =
  +type ReaderIndexedStateBuilder () =
       // 'T -> M<'T>
       member __.Return value
  -        : ReaderStateFuncIndexed<'Env, 'State, 'State, 'T> =
  +        : ReaderIndexedStateFunc<'Env, 'State, 'State, 'T> =
           fun env state ->
           value, state
   
       // M<'T> -> M<'T>
       member __.ReturnFrom func
  -        : ReaderStateFuncIndexed<'Env, 'S1, 'S2, 'T> =
  +        : ReaderIndexedStateFunc<'Env, 'S1, 'S2, 'T> =
           func
   
       // unit -> M<'T>
       member this.Zero ()
  -        : ReaderStateFuncIndexed<'Env, 'State, 'State, unit> =
  +        : ReaderIndexedStateFunc<'Env, 'State, 'State, unit> =
           this.Return ()
   
       // M<'T> * ('T -> M<'U>) -> M<'U>
  -    member __.Bind (m : ReaderStateFuncIndexed<_,_,'S2,_>, k : 'T -> ReaderStateFuncIndexed<_,_,_,_>)
  -        : ReaderStateFuncIndexed<'Env, 'S1, 'S3, 'U> =
  +    member __.Bind (m : ReaderIndexedStateFunc<_,_,'S2,_>, k : 'T -> ReaderIndexedStateFunc<_,_,_,_>)
  +        : ReaderIndexedStateFunc<'Env, 'S1, 'S3, 'U> =
           fun env state ->
               let result, state = m env state
               (k result) env state
   
       // (unit -> M<'T>) -> M<'T>
  -    member this.Delay (f : unit -> ReaderStateFuncIndexed<_,_,_,_>)
  -        : ReaderStateFuncIndexed<'Env, 'S1, 'S2, 'T> =
  +    member this.Delay (f : unit -> ReaderIndexedStateFunc<_,_,_,_>)
  +        : ReaderIndexedStateFunc<'Env, 'S1, 'S2, 'T> =
           this.Bind (this.Return (), f)
   
       // M<'T> -> M<'T> -> M<'T>
       // or
       // M<unit> -> M<'T> -> M<'T>
  -    member this.Combine (r1 : ReaderStateFuncIndexed<_,_,'S2,_>, r2 : ReaderStateFuncIndexed<_,_,_,_>)
  -        : ReaderStateFuncIndexed<'Env, 'S1, 'S3, 'T> =
  +    member this.Combine (r1 : ReaderIndexedStateFunc<_,_,'S2,_>, r2 : ReaderIndexedStateFunc<_,_,_,_>)
  +        : ReaderIndexedStateFunc<'Env, 'S1, 'S3, 'T> =
           this.Bind (r1, fun () -> r2)
   
       // M<'T> -> M<'T> -> M<'T>
  -    member __.TryWith (body : ReaderStateFuncIndexed<_,_,_,_>, handler : exn -> ReaderStateFuncIndexed<_,_,_,_>)
  -        : ReaderStateFuncIndexed<'Env, 'S1, 'S2, 'T> =
  +    member __.TryWith (body : ReaderIndexedStateFunc<_,_,_,_>, handler : exn -> ReaderIndexedStateFunc<_,_,_,_>)
  +        : ReaderIndexedStateFunc<'Env, 'S1, 'S2, 'T> =
           fun env state ->
               try body env state
               with ex ->
                   handler ex env state
   
       // M<'T> -> M<'T> -> M<'T>
  -    member __.TryFinally (body : ReaderStateFuncIndexed<_,_,_,_>, handler)
  -        : ReaderStateFuncIndexed<'Env, 'S1, 'S2, 'T> =
  +    member __.TryFinally (body : ReaderIndexedStateFunc<_,_,_,_>, handler)
  +        : ReaderIndexedStateFunc<'Env, 'S1, 'S2, 'T> =
           fun env state ->
               try body env state
               finally
                   handler ()
   
       // 'T * ('T -> M<'U>) -> M<'U> when 'U :> IDisposable
  -    member this.Using (resource : ('T :> System.IDisposable), body : _ -> ReaderStateFuncIndexed<_,_,_,_>)
  -        : ReaderStateFuncIndexed<'Env, 'S1, 'S2, 'U> =
  +    member this.Using (resource : ('T :> System.IDisposable), body : _ -> ReaderIndexedStateFunc<_,_,_,_>)
  +        : ReaderIndexedStateFunc<'Env, '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 : ReaderStateFuncIndexed<_,_,_,_>)
  -        : ReaderStateFuncIndexed<'Env, 'State, 'State, unit> =
  +    member this.While (guard, body : ReaderIndexedStateFunc<_,_,_,_>)
  +        : ReaderIndexedStateFunc<'Env, 'State, 'State, unit> =
           if guard () then
               this.Bind (body, (fun () -> this.While (guard, body)))
           else
  
positive.code: /// <typeparam name="S1"></typeparam>
  /// <typeparam name="S2"></typeparam>
  /// <typeparam name="T"></typeparam>
  type StateFuncIndexed<'S1, 'S2, 'T> =
      'S1 -> 'T * 'S2
  
  /// <summary>
  
negative.code: /// <typeparam name="S1"></typeparam>
  /// <typeparam name="S2"></typeparam>
  /// <typeparam name="T"></typeparam>
  type ReaderWriterIndexedStateFunc<'Env, 'Writer, 'S1, 'S2, 'T> =
      //'Env -> 'S1 -> ('T * 'S2) * 'Writer
      'Env -> 'S1 -> 'T * 'S2 * 'Writer
  
  