anchor.diff:    /// sequences are consumed in lock-step.
     let interleave = 
   
  -    let rec left (a:AsyncSeq<'a>) (b:AsyncSeq<'b>) : AsyncSeq<Choice<_,_>> = async {
  +    let rec left (a:AsyncSeq<'T>) (b:AsyncSeq<'U>) : AsyncSeq<Choice<_,_>> = async {
         let! a = a        
         match a with
         | Cons (a1, t1) -> return Cons (Choice1Of2 a1, right t1 b)
         | Nil -> return! b |> map Choice2Of2 }
   
  -    and right (a:AsyncSeq<'a>) (b:AsyncSeq<'b>) : AsyncSeq<Choice<_,_>> = async {
  +    and right (a:AsyncSeq<'T>) (b:AsyncSeq<'U>) : AsyncSeq<Choice<_,_>> = async {
         let! b = b        
         match b with
         | Cons (a2, t2) -> return Cons (Choice2Of2 a2, left a t2)
  
positive.code:     module internal Choice =
    
        /// Maps over the left result type.
        let mapl (f:'a -> 'b) = function
          | Choice1Of2 a -> f a |> Choice1Of2
          | Choice2Of2 e -> Choice2Of2 e
  
        /// Maps over the right result type.
        let mapr (f:'b -> 'c) = function
          | Choice1Of2 a -> Choice1Of2 a
          | Choice2Of2 e -> f e |> Choice2Of2
  
      // ----------------------------------------------------------------------------
  
  
negative.code: 
        /// Creates an async computations which runs the specified computations
        /// in parallel and returns their results.
        static member Parallel(a:Async<'T>, b:Async<'U>) : Async<'T * 'U> = async {
          let! a = a |> Async.StartChild
          let! b = b |> Async.StartChild
          let! a = a
  