anchor.diff:    ///
     /// The aggregation function is asynchronous (and the input sequence will
     /// be asked for the next element after the processing of an element completes).
  -  let rec scanAsync f (state:'TState) (input : AsyncSeq<'T>) = asyncSeq {
  +  let rec scanAsync f (state:'State) (input : AsyncSeq<'T>) = asyncSeq {
       let! v = input
       match v with
       | Nil -> ()
  
positive.code:       | Cons (a2, t2) -> return Cons (Choice2Of2 a2, left a t2)
        | Nil -> return! a |> map Choice1Of2 }
  
      left
  
    /// Buffer items from the async sequence into buffers of a specified size.
    /// The last buffer returned may be less than the specified buffer size.
  
negative.code:   ///
    /// The aggregation function is asynchronous (and the input sequence will
    /// be asked for the next element after the processing of an element completes).
    let rec foldAsync f (state:'State) (input : AsyncSeq<'T>) = 
      input |> scanAsync f state |> lastOrDefault state
  
    /// Same as AsyncSeq.foldAsync, but the specified function is synchronous
    /// and returns the result of aggregation immediately.
    let rec fold f (state:'State) (input : AsyncSeq<'T>) = 
      foldAsync (fun st v -> f st v |> async.Return) state input 
  
    /// Same as AsyncSeq.scanAsync, but the specified function is synchronous
    /// and returns the result of aggregation immediately.
    let rec scan f (state:'State) (input : AsyncSeq<'T>) = 
      scanAsync (fun st v -> f st v |> async.Return) state input 
  
    /// Same as AsyncSeq.mapAsync, but the specified function is synchronous
  