anchor.diff:            | Some y -> cons y (choose x2yO xs)
   
     let rec map x2y xs =
  -    xs |>>* function
  -       | Nil -> Nil
  -       | Cons (x, xs) -> Cons (x2y x, map x2y xs)
  +    xs |>>* function Nil -> Nil
  +                   | Cons (x, xs) -> Cons (x2y x, map x2y xs)
   
     let rec joinWith (join: Streams<_> -> Streams<_> -> Streams<_>)
                      (xxs: Streams<Streams<_>>) =
  
positive.code:          override this.Dispose () =
            lock subs <| fun () -> subs.Remove xS |> ignore}}
  
    let rec ofAlt xA = xA |>>* fun x -> Cons (x, ofAlt xA)
  
    let rec merge ls rs =
      mergeSwap ls rs <|>* mergeSwap rs ls
    and mergeSwap ls rs =
      ls |>>? function
         | Nil -> Nil
         | Cons (l, ls) -> Cons (l, merge rs ls)
  
    let rec append (ls: Streams<_>) (rs: Streams<_>) =
      ls >>=* function
  
negative.code:          upcast append (takeUntil xs (x2ys x)) (collectLatest x2ys xs)
  
    let rec throttle timeout xs =
      xs >>=* function Nil -> nil
                     | Cons (x, xs) -> throttleGot1 timeout xs x
    and throttleGot1 timeout xs x =
      (timeout >>=? fun _ -> cons x (throttle timeout xs)) <|>
      (xs >>=? function Nil -> cons x zero
                      | Cons (x, xs) -> throttleGot1 timeout xs x)
  
    let rec zipXY f x xs y ys =
      let gotx = xs >>=? function Nil -> nil | Cons (x, xs) -> zipXY f x xs y ys
  