anchor.diff:      head s
   
     /// Returns an async sequence which contains no contiguous duplicate elements based on the specified comparison function.
  -  let distinctUntilChangedWith (f:'a -> 'a -> bool) (s:AsyncSeq<'a>) : AsyncSeq<'a> =
  +  let distinctUntilChangedWith (f:'T -> 'T -> bool) (s:AsyncSeq<'T>) : AsyncSeq<'T> =
       distinctUntilChangedWithAsync (fun a b -> f a b |> async.Return) s
   
     /// Returns an async sequence which contains no contiguous duplicate elements.
  -  let distinctUntilChanged (s:AsyncSeq<'a>) : AsyncSeq<'a> =
  +  let distinctUntilChanged (s:AsyncSeq<'T>) : AsyncSeq<'T> =
       distinctUntilChangedWith ((=)) s
           
       
  
positive.code:       /// Creates a computation which produces a tuple consiting of the value produces by the first
        /// argument computation to complete and a handle to the other computation. The second computation
        /// to complete is memoized.
        static member internal chooseBoth (a:Async<'a>) (b:Async<'a>) : Async<'a * Async<'a>> =
          Async.FromContinuations <| fun (ok,err,cnc) ->
            let state = ref 0            
            let tcs = TaskCompletionSource<'a>()            
            let inline ok a =
              if (Interlocked.CompareExchange(state, 1, 0) = 0) then
                ok (a, tcs.Task |> Async.AwaitTask)
  
negative.code:     | Nil -> return Nil }
  
    /// Skips elements from an async sequence until the specified signal completes.
    let rec skipUntil (signal:Async<unit>) (s:AsyncSeq<'T>) : AsyncSeq<'T> =
      Async.chooseBoth (signal |> Async.map Choice1Of2) (s |> Async.map Choice2Of2)
      |> Async.bind (fun (first,second) ->
        match first with
  