anchor.diff:    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 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 () ->
  
positive.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
  
negative.code:           | 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)
  
    let rec joinWith (join: Streams<_> -> Streams<_> -> Streams<_>)
                     (xxs: Streams<Streams<_>>) =
  