anchor.diff:  
     /// Interleaves two async sequences into a resulting sequence. The provided
     /// sequences are consumed in lock-step.
  -  let interleave = 
  +  let interleave (firstSeq: AsyncSeq<'T1>) (secondSeq: AsyncSeq<'T1>) = 
   
       let rec left (a:AsyncSeq<'T>) (b:AsyncSeq<'U>) : AsyncSeq<Choice<_,_>> = async {
         let! a = a        
  
positive.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:'TState) (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:'TState) (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:'TState) (input : AsyncSeq<'T>) = 
      scanAsync (fun st v -> f st v |> async.Return) state input 
  
    /// Same as AsyncSeq.mapAsync, but the specified function is synchronous
  
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 scanAsync f (state:'State) (input : AsyncSeq<'T>) = asyncSeq {
      let! v = input
      match v with
      | Nil -> ()
  