anchor.diff:              while true do
                   // Allow timeout (when the observable ends, caller will
                   // cancel the agent, so we need timeout to allow cancellation)
  -                let! msg = mbox.TryReceive(200)
  +                let! msg = mbox.TryReceive 200
                   match msg with
                   | None
                   | Some (Put _) ->
  
positive.code:     /// Tries to get the next element of an asynchronous sequence
      /// and returns either the value or an exception.
      // TODO : Simplify this to use the built-in Async.Catch method.
      let private tryNext (input : AsyncSeq<_>) =
          async {
          try
              let! v = input
              return Choice1Of2 v
          with ex ->
              return Choice2Of2 ex
  
negative.code:     /// sequentially iterated over (at the maximal possible speed). Disposing of the 
      /// observer cancels the iteration over asynchronous sequence.
      [<CompiledName("ToObservable")>]
      let toObservable (source : AsyncSeq<'T>) =
          // Preconditions
          checkNonNull "source" source
  
          let start (obs : IObserver<_>) =
              async {
              try
                  for v in source do
                      obs.OnNext v
                  obs.OnCompleted ()
              with ex ->
                  obs.OnError ex }
              |> Async.StartDisposable
  
          { new IObservable<_> with
              member x.Subscribe observer =
                  // Preconditions
                  checkNonNull "observer" observer
  
                  start observer }
  
      (* Synchronous functions. These may be removed in the near future. *)
  
      /// 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) (source : AsyncSeq<'T>) =
          // Preconditions
          checkNonNull "source" source
  
          foldAsync (fun st v -> folder st v |> async.Return) state source
  
      /// 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) (source : AsyncSeq<'T>) : AsyncSeq<'State> =
          // Preconditions
          checkNonNull "source" source
  
          scanAsync (fun st v -> folder st v |> async.Return) state source
  
      /// Same as AsyncSeq.mapAsync, but the specified function is synchronous
      /// and returns the result of projection immediately.
      [<CompiledName("Map")>]
      let map mapping (source : AsyncSeq<'T>) =
          // Preconditions
          checkNonNull "source" source
  
          mapAsync (mapping >> async.Return) source
  
      /// Same as AsyncSeq.iterAsync, but the specified function is synchronous
      /// and performs the side-effect immediately.
      [<CompiledName("Iter")>]
      let iter action (source : AsyncSeq<'T>) =
          // Preconditions
          checkNonNull "source" source
  
          iterAsync (action >> async.Return) source
  
      /// Same as AsyncSeq.chooseAsync, but the specified function is synchronous
      /// and processes the input element immediately.
      [<CompiledName("Choose")>]
      let choose chooser (source : AsyncSeq<'T>) : AsyncSeq<'U> =
          // Preconditions
          checkNonNull "source" source
  
          chooseAsync (chooser >> async.Return) source
  
      /// Same as AsyncSeq.filterAsync, but the specified predicate is synchronous
      /// and processes the input element immediately.
      [<CompiledName("Filter")>]
      let filter predicate (source : AsyncSeq<'T>) : AsyncSeq<'T> =
          // Preconditions
          checkNonNull "source" source
  
          filterAsync (predicate >> async.Return) source
  
      /// Returns elements from an asynchronous sequence while the specified
      /// predicate holds. The predicate is evaluated synchronously.
      [<CompiledName("TakeWhile")>]
      let rec takeWhile predicate (source : AsyncSeq<'T>) : AsyncSeq<'T> =
          // Preconditions
          checkNonNull "source" source
  
          takeWhileAsync (predicate >> async.Return) source
  
      /// Skips elements from an asynchronous sequence while the specified 
      /// predicate holds and then returns the rest of the sequence. The 
      /// predicate is evaluated asynchronously.
      [<CompiledName("SkipWhile")>]
      let rec skipWhile predicate (source : AsyncSeq<'T>) : AsyncSeq<'T> =
          // Preconditions
          checkNonNull "source" source
  
          skipWhileAsync (predicate >> async.Return) source
  
  (*
  //
  