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:     | hd::tl -> merge hd (mergeAll tl)
        
    /// Returns an async sequence which contains no contiguous duplicate elements based on the specified comparison function.
    let distinctUntilChangedWithAsync (f:'a -> 'a -> Async<bool>) (s:AsyncSeq<'a>) : AsyncSeq<'a> =     
      
      // return the head, if any, then the tail passing the previous element
      let rec head s =
  
negative.code: 
    /// Traverses an async sequence an applies to specified function such that if Choice2Of2 is returned the traversal short-circuits
    /// and Choice2Of2 is returned as the result. Otherwise, the entire sequence is traversed and the result returned as Choice1Of2.
    let rec traverseChoiceAsync (f:'T -> Async<Choice<'U, 'e>>) (s:AsyncSeq<'T>) : Async<Choice<AsyncSeq<'U>, 'e>> = async {
      let! s = s
      match s with
      | Nil -> return Choice1Of2 (Nil |> async.Return)
  