anchor.diff:           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
  +    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)
  +    (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
  
positive.code:   let one x = Alt.always (Cons (x, zero<_>)) :> Streams<'x>
  
    let inline memo x = Promise.Now.delayAsAlt x
    let inline (>>=*) x f = x >>=? f |> memo
    let inline (|>>*) x f = x |>>? f |> memo
    let inline (<|>*) x y = x <|> y |> memo
  
    let rec ofEnum (xs: IEnumerator<'x>) = memo << Job.thunk <| fun () ->
  
negative.code:          override this.Dispose () =
            lock subs <| fun () -> subs.Remove xS |> ignore}}
  
    let rec ofAlt (xA: Alt<_>) = 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
  