anchor.diff:  
     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<_>) =
  
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:     (mapc (holdGot1 timeout timer) xs)
    and hold timeout xs = mapcm (holdGot1 timeout (memo timeout)) xs
  
    let rec clXY x xs y ys = Cons ((x, y), clY xs y ys <|>* clX ys x xs)
    and clYX y ys x xs = Cons ((x, y), clX ys x xs <|>* clY xs y ys)
    and clX ys x xs = mapfc (clXY x xs) ys
    and clY xs y ys = mapfc (clYX y ys) xs
    let combineLatest xs ys = mapc (clX ys) xs <|>* mapc (clY xs) ys
  
    let rec zipXY x y xs ys = Cons ((x, y), zip xs ys)
    and zipX ys x xs = mapfc (fun y ys -> zipXY x y xs ys) ys
    and zipY xs y ys = mapfc (fun x xs -> zipXY x y xs ys) xs
    and zip xs ys = mapc (zipX ys) xs <|>* mapc (zipY xs) ys
  
    let rec scanJob f s xs =
  