anchor.diff:  
   
     let delay (f: unit -> AsyncSeq<'T>) : AsyncSeq<'T> = 
  -        { new IAsyncEnumerable<'T> with 
  -              member x.GetEnumerator() = f().GetEnumerator() }
  +      { new IAsyncEnumerable<'T> with 
  +          member x.GetEnumerator() = f().GetEnumerator() }
  +
  +
  +  type BindState =
  +     | NotStarted     = -1
  +     | HaveEnumerator = 0
  +     | Finished        = 1
   
     let bindAsync (f: 'T -> AsyncSeq<'U>) (inp : Async<'T>) : AsyncSeq<'U> = 
           { new IAsyncEnumerable<'U> with 
                 member x.GetEnumerator() = 
  -                  let state = ref -1
  -                  // state -1 = not started
  -                  // state 0 = have result enumerator
  -                  // state 1 = finished
  +                  let state = ref BindState.NotStarted
                     let enum = ref Unchecked.defaultof<IAsyncEnumerator<'U>>
                     { new IAsyncEnumerator<'U> with 
                           member x.MoveNext() = 
                               async { match !state with 
  -                                    | -1 -> 
  +                                    | BindState.NotStarted -> 
                                           let! v = inp 
                                           return! 
                                              (let s = f v
                                               let e = s.GetEnumerator()
                                               enum := e
  -                                            state := 0
  +                                            state := BindState.HaveEnumerator
                                               x.MoveNext())
  -                                    | 0 ->   
  +                                    | BindState.HaveEnumerator ->   
                                           let! res = enum.Value.MoveNext() 
                                           return (match res with
                                                   | None -> 
  
positive.code:                                         | Choice2Of2 exn -> 
                                              return! 
                                                (x.Dispose()
                                                 state := 2
                                                 enum := (handler exn).GetEnumerator()
                                                 state := 3
                                                 x.MoveNext())
                                      | 3 ->   
                                          let! res = enum.Value.MoveNext() 
                                          return (match res with 
                                                  | Some _ -> res
  
negative.code:                         member x.Dispose() = () } }
      
    type AppendState =
       | NotStarted1     = -1
       | HaveEnumerator1 = 0
       | NotStarted2     = 1
       | HaveEnumerator2 = 2
       | Finished        = 3
  
    let append (inp1: AsyncSeq<'T>) (inp2: AsyncSeq<'T>) : AsyncSeq<'T> =
  