anchor.diff:  type StatefulChoiceBuilder () =
       // 'T -> M<'T>
       member __.Return value
  -        : StatefulChoiceFuncClamped<'State, 'T, 'Error> =
  +        : StatefulChoiceFunc<'State, 'T, 'Error> =
           fun state ->
           (Choice1Of2 value), state
   
       // M<'T> -> M<'T>
       member __.ReturnFrom (func)
  -        : StatefulChoiceFunc<_,_,_,_> =
  +        : StatefulChoiceFuncIndexed<_,_,_,_> =
           func
   
       // unit -> M<'T>
       member this.Zero ()
  -        : StatefulChoiceFuncClamped<'State, unit, 'Error> =
  +        : StatefulChoiceFunc<'State, unit, 'Error> =
           fun state ->
           (Choice1Of2 ()), state
   
       // (unit -> M<'T>) -> M<'T>
  -    member this.Delay (f : unit -> StatefulChoiceFunc<_,_,_,_>)
  -        : StatefulChoiceFunc<'S1, 'S2, 'T, 'Error> =
  +    member this.Delay (f : unit -> StatefulChoiceFuncIndexed<_,_,_,_>)
  +        : StatefulChoiceFuncIndexed<'S1, 'S2, 'T, 'Error> =
           fun state -> f () state
   
       // M<'T> * ('T -> M<'U>) -> M<'U>
  -    member __.Bind (f : StatefulChoiceFunc<_,_,_,_>, k : 'T -> StatefulChoiceFuncClamped<_,_,_>)
  -        : StatefulChoiceFunc<'S1, 'S2, 'U, 'Error> =
  +    member __.Bind (f : StatefulChoiceFuncIndexed<_,_,_,_>, k : 'T -> StatefulChoiceFunc<_,_,_>)
  +        : StatefulChoiceFuncIndexed<'S1, 'S2, 'U, 'Error> =
           fun state ->
           match f state with
           | (Choice1Of2 value), state ->
  
positive.code: /// <typeparam name="S2"></typeparam>
  /// <typeparam name="T"></typeparam>
  /// <typeparam name="K"></typeparam>
  type StateContinuationFunc<'S1, 'S2, 'T, 'K> =
      'S1 -> ('T * 'S2 -> 'K) -> 'K
  
  /// <summary>
  
negative.code: /// <typeparam name="S1"></typeparam>
  /// <typeparam name="S2"></typeparam>
  /// <typeparam name="T"></typeparam>
  type ReaderStateFuncIndexed<'Env, 'S1, 'S2, 'T> =
      'Env -> 'S1 -> 'T * 'S2
  
  /// <summary>
  /// Synonym for ReaderStateFuncIndexed where the initial and final state are "clamped" to the
  /// same type. In other words, the function does not change the type of the state value.
  /// </summary>
  /// <typeparam name="Env"></typeparam>
  /// <typeparam name="State"></typeparam>
  /// <typeparam name="T"></typeparam>
  type ReaderStateFunc<'Env, 'State, 'T> =
      ReaderStateFuncIndexed<'Env, 'State, 'State, 'T>
  
  /// <summary>
  /// 
  