anchor.diff:       | Finished 
   
     let collect (f: 'T -> AsyncSeq<'U>) (inp: AsyncSeq<'T>) : AsyncSeq<'U> = 
  -        // Note: this is put outside the object deliberately, so the object doesn't permanently capture inp1 and inp2
  -        let initialState = NotStarted inp
           { new IAsyncEnumerable<'U> with 
                 member x.GetEnumerator() = 
  -                  let state = ref initialState
  +                  let state = ref (CollectState.NotStarted inp)
                     { new IAsyncEnumerator<'U> with 
                           member x.MoveNext() = 
                               async { match !state with 
  -                                    | NotStarted inp -> 
  +                                    | CollectState.NotStarted inp -> 
                                           return! 
                                              (let e1 = inp.GetEnumerator()
  -                                            state := HaveInputEnumerator e1
  +                                            state := CollectState.HaveInputEnumerator e1
                                               x.MoveNext())
  -                                    | HaveInputEnumerator e1 ->   
  +                                    | CollectState.HaveInputEnumerator e1 ->   
                                           let! res1 = e1.MoveNext() 
                                           return! 
                                              (match res1 with
                                               | Some v1 ->
                                                   let e2 = (f v1).GetEnumerator()
  -                                                state := HaveInnerEnumerator (e1, e2)
  +                                                state := CollectState.HaveInnerEnumerator (e1, e2)
                                               | None -> 
                                                   x.Dispose()
                                               x.MoveNext())
  -                                    | HaveInnerEnumerator (e1, e2) ->   
  +                                    | CollectState.HaveInnerEnumerator (e1, e2) ->   
                                           let! res2 = e2.MoveNext() 
                                           match res2 with 
                                           | None ->
  -                                            state := HaveInputEnumerator e1
  +                                            state := CollectState.HaveInputEnumerator e1
                                               dispose e2
                                               return! x.MoveNext()
                                           | Some _ -> 
  
positive.code:   /// Implements the 'TryWith' functionality for computation builder
    let tryWith (inp: AsyncSeq<'T>) (handler : exn -> AsyncSeq<'T>) : AsyncSeq<'T> = 
          // Note: this is put outside the object deliberately, so the object doesn't permanently capture inp1 and inp2
          let initialState = NotStarted inp
          { new IAsyncEnumerable<'T> with 
                member x.GetEnumerator() = 
                    let state = ref initialState
                    { new IAsyncEnumerator<'T> with 
                          member x.MoveNext() = 
                              async { match !state with 
                                      | NotStarted inp -> 
                                          let res = ref Unchecked.defaultof<_>
                                          try 
                                              res := Choice1Of2 (inp.GetEnumerator())
  
negative.code:           let! moven = ie.MoveNext() 
            b := moven }
  
    [<RequireQualifiedAccess>]
    type TryWithState<'T> =
       | NotStarted of AsyncSeq<'T>
       | HaveBodyEnumerator of IAsyncEnumerator<'T>
  