anchor.diff:  [<RequireQualifiedAccess; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
   module State =
       //
  -    let inline run (stateFunc : StateFunc<'S1, 'S2, 'T>) initialState =
  +    let inline run (stateFunc : StateFuncIndexed<'S1, 'S2, 'T>) initialState =
           stateFunc initialState
       
       //
  -    let evaluate (stateFunc : StateFunc<'S1, 'S2, 'T>) initialState =
  +    let evaluate (stateFunc : StateFuncIndexed<'S1, 'S2, 'T>) initialState =
           // "Run" the state function, starting with the initial state.
           // Discard the final state value and return the final result value.
           fst <| stateFunc initialState
   
       //
  -    let execute (stateFunc : StateFunc<'S1, 'S2, 'T>) initialState =
  +    let execute (stateFunc : StateFuncIndexed<'S1, 'S2, 'T>) initialState =
           // "Run" the state function, starting with the initial state.
           // Discard the final result value and return the final state value.
           snd <| stateFunc initialState
  
positive.code: type ProtectedStateContinuationBuilder () =
      // 'T -> M<'T>
      member inline __.Return value
          : ProtectedStateContinuationFuncClamped<'State, 'T, 'Error, 'K> =
          fun state cont ->
              cont (Choice1Of2 (value, state))
  
      // M<'T> -> M<'T>
      member inline __.ReturnFrom func
          : ProtectedStateContinuationFunc<'S1, 'S2, 'T, 'Error, 'K> =
          func
  
      // unit -> M<'T>
      member inline __.Zero ()
          : ProtectedStateContinuationFuncClamped<'State, unit, 'Error, 'K> =
          fun state cont ->
              cont (Choice1Of2 ((), state))
  
      // (unit -> M<'T>) -> M<'T>
      member __.Delay f
          : ProtectedStateContinuationFunc<'S1, 'S2, 'T, 'Error, 'K> =
          f ()
  
      // M<'T> * ('T -> M<'U>) -> M<'U>
      member inline __.Bind (m : ProtectedStateContinuationFunc<_,_,_,_,_>, k : 'T -> ProtectedStateContinuationFunc<_,_,_,_,_>) =
          fun state cont ->
              m state <| fun result ->
                  match result with
  
negative.code:     // M<'T> -> M<'T> -> M<'T>
      // or
      // M<unit> -> M<'T> -> M<'T>
      member this.Combine (r1 : StatefulChoiceFuncIndexed<_,_,_,_>, r2 : StatefulChoiceFunc<_,_,_>)
          : StatefulChoiceFuncIndexed<'S1, 'S2, 'T, 'Error> =
          this.Bind (r1, (fun () -> r2))
  
      // M<'T> -> M<'T> -> M<'T>
      member __.TryWith (body : StatefulChoiceFuncIndexed<_,_,_,_>, handler : exn -> StatefulChoiceFuncIndexed<_,_,_,_>)
          : StatefulChoiceFuncIndexed<'S1, 'S2, 'T, 'Error> =
          fun state ->
          try body state
          with ex ->
              handler ex state
  
      // M<'T> -> M<'T> -> M<'T>
      member __.TryFinally (body : StatefulChoiceFuncIndexed<_,_,_,_>, handler)
          : StatefulChoiceFuncIndexed<'S1, 'S2, 'T, 'Error> =
          fun state ->
          try body state
          finally
              handler ()
  
      // 'T * ('T -> M<'U>) -> M<'U> when 'U :> IDisposable
      member this.Using (resource : ('T :> System.IDisposable), body : 'T -> StatefulChoiceFuncIndexed<_,_,_,_>)
          : StatefulChoiceFuncIndexed<'S1, 'S2, 'U, 'Error> =
          this.TryFinally (body resource, (fun () ->
              if not <| isNull (box resource) then
                  resource.Dispose ()))
  
      // (unit -> bool) * M<'T> -> M<'T>
      member this.While (guard, body : StatefulChoiceFunc<_,_,_>)
          : StatefulChoiceFunc<'State, _, 'Error> =
          if guard () then
              this.Bind (body, (fun () -> this.While (guard, body)))
          else
  