anchor.diff:      /// predicate is evaluated asynchronously.
       [<CompiledName("SkipWhileAsync")>]
       let rec skipWhileAsync predicate (input : AsyncSeq<'T>) : AsyncSeq<'T> =
  +        // Preconditions
  +        checkNonNull "input" input
  +
           async {
           let! v = input
           match v with
  
positive.code:     /// given asynchronous sequence (or the specified default value).
      [<CompiledName("LastOrDefault")>]
      let rec lastOrDefault defaultValue (input : AsyncSeq<'T>) =
          async {
          let! v = input
          match v with
  
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("FoldAsync")>]
      let rec foldAsync folder (state : 'State) (input : AsyncSeq<'T>) =
          // Preconditions
          checkNonNull "input" input
  
          input |> scanAsync folder state |> lastOrDefault state
  
      /// Same as AsyncSeq.foldAsync, but the specified function is synchronous
      /// and returns the result of aggregation immediately.
      [<CompiledName("Fold")>]
      let rec fold folder (state : 'State) (input : AsyncSeq<'T>) =
          // Preconditions
          checkNonNull "input" input
  
          foldAsync (fun st v -> folder st v |> async.Return) state input
  
      /// Same as AsyncSeq.scanAsync, but the specified function is synchronous
      /// and returns the result of aggregation immediately.
      [<CompiledName("Scan")>]
      let rec scan folder (state : 'State) (input : AsyncSeq<'T>) : AsyncSeq<'State> =
          // Preconditions
          checkNonNull "input" input
  
          scanAsync (fun st v -> folder st v |> async.Return) state input
  
      /// Same as AsyncSeq.mapAsync, but the specified function is synchronous
      /// and returns the result of projection immediately.
      [<CompiledName("Map")>]
      let map mapping (input : AsyncSeq<'T>) =
          // Preconditions
          checkNonNull "input" input
  
          mapAsync (mapping >> async.Return) input
  
      /// Same as AsyncSeq.iterAsync, but the specified function is synchronous
      /// and performs the side-effect immediately.
      [<CompiledName("Iter")>]
      let iter action (input : AsyncSeq<'T>) =
          // Preconditions
          checkNonNull "input" input
  
          iterAsync (action >> async.Return) input
  
      /// Same as AsyncSeq.chooseAsync, but the specified function is synchronous
      /// and processes the input element immediately.
      [<CompiledName("Choose")>]
      let choose chooser (input : AsyncSeq<'T>) : AsyncSeq<'U> =
          // Preconditions
          checkNonNull "input" input
  
          chooseAsync (chooser >> async.Return) input
  
      /// Same as AsyncSeq.filterAsync, but the specified predicate is synchronous
      /// and processes the input element immediately.
      [<CompiledName("Filter")>]
      let filter predicate (input : AsyncSeq<'T>) : AsyncSeq<'T> =
          // Preconditions
          checkNonNull "input" input
  
          filterAsync (predicate >> async.Return) input
  
      // --------------------------------------------------------------------------
  