anchor.diff:      /// The specified function is asynchronous (and the input sequence will
       /// be asked for the next element after the processing of an element completes).
       [<CompiledName("FilterAsync")>]
  -    let filterAsync predicate (input : AsyncSeq<'T>) : AsyncSeq<'T> =
  -        // Preconditions
  -        checkNonNull "input" input
  +    let filterAsync predicate (source : AsyncSeq<'T>) : AsyncSeq<'T> =
  +        // Preconditions
  +        checkNonNull "source" source
   
           asyncSeq {
  -        for v in input do
  +        for v in source do
               let! b = predicate v
               if b then
                   yield v }
  -
  -    /// Asynchronously returns the last element that was generated by the
  -    /// given asynchronous sequence (or the specified default value).
  -    [<CompiledName("LastOrDefault")>]
  -    let rec lastOrDefault defaultValue (input : AsyncSeq<'T>) =
  -        // Preconditions
  -        checkNonNull "input" input
  -
  -        async {
  -        let! v = input
  -        match v with
  -        | Nil ->
  -            return defaultValue
  -        | Cons (h, t) ->
  -            return! lastOrDefault h t }
  -
  -    /// Asynchronously returns the first element that was generated by the
  -    /// given asynchronous sequence (or the specified default value).
  -    [<CompiledName("FirstOrDefault")>]
  -    let firstOrDefault defaultValue (input : AsyncSeq<'T>) =
  -        // Preconditions
  -        checkNonNull "input" input
  -
  -        async {
  -        let! v = input
  -        match v with
  -        | Nil ->
  -            return defaultValue
  -        | Cons(h, _) ->
  -            return h }
   
       /// Aggregates the elements of the input asynchronous sequence using the
       /// specified 'aggregation' function. The result is an asynchronous
  
positive.code:     /// The specified function is asynchronous (and the input sequence will
      /// be asked for the next element after the processing of an element completes).
      [<CompiledName("ChooseAsync")>]
      let chooseAsync chooser (input : AsyncSeq<'T>) : AsyncSeq<'U> =
          // Preconditions
          checkNonNull "input" input
  
          asyncSeq {
          for itm in input do
              let! v = chooser itm
              match v with
              | None -> ()
  
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).
      [<CompiledName("ScanAsync")>]
      let rec scanAsync folder (state : 'State) (source : AsyncSeq<'T>) : AsyncSeq<'State> =
          // Preconditions
          checkNonNull "source" source
  
          asyncSeq {
          let! v = source
          match v with
          | Nil -> ()
          | Cons (hd, tl) ->
              let! v = folder state hd
              yield v
              yield! scanAsync folder v tl }
  
      /// Iterates over the input sequence and calls the specified function for
      /// every value (to perform some side-effect asynchronously).
  