anchor.diff:    let rec sampleGot0 ts xs =
       mapc (fun _ ts -> sampleGot0 ts xs) ts <|>? mapc (sampleGot1 ts) xs
     and sampleGot1 ts x xs =
  -    mapc (fun _ ts -> cons x (sample ts xs)) ts <|>? mapc (sampleGot1 ts) xs
  +    mapfc (fun _ ts -> Cons (x, sample ts xs)) ts <|>? mapc (sampleGot1 ts) xs
     and sample ts xs = sampleGot0 ts xs |> memo
   
     let rec skip' n xs = if 0 < n then mapc (fun _ -> skip' (n-1)) xs else xs
     let skip n xs = if n < 0 then failwith "skip: n < 0" else skip' n xs |> memo
   
     let rec take' n xs =
  -    if 0 < n then mapcm (fun x -> cons x << take' (n-1)) xs else nil
  +    if 0 < n then mapfcm (fun x xs -> Cons (x, take' (n-1) xs)) xs else nil
     let take n xs = if n < 0 then failwith "take: n < 0" else take' n xs
   
     let inline mapcnm f (xs: Streams<_>) =
  
positive.code:     let raised e =
        key2br.Values |> Seq.iterJob (fun i -> i <-=! e) >>. (!main <-=! e) >>! e
      let rec wrap self xs newK oldK =
        (mapc (fun x xs -> cons x (self xs)) xs) <|>*
        (let rec serve ss =
           Job.tryIn ss
            <| function
  
negative.code: 
    let onceJob xJ = xJ |>>* fun x -> Cons (x, nil)
  
    let inline mapfC c = function Nil -> Nil | Cons (x, xs) -> c x xs
    let inline mapfc c xs = xs |>>? mapfC c
    let inline mapfcm c xs = mapfc c xs |> memo
  
    let inline mapnc n (c: _ -> _ -> #Job<_>) xs =
      xs >>=? function Nil -> n | Cons (x, xs) -> c x xs
    let inline mapC (c: _ -> _ -> #Job<_>) =
  