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:     (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 = mapc (clXY x xs) ys
    and clY xs y ys = mapc (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 = mapc (fun y ys -> zipXY x y xs ys) ys
    and zipY xs y ys = mapc (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 =
  
negative.code:   let filterFun x2b xs = filterJob (x2b >> Job.result) xs
  
    let mapJob x2yJ xs = chooseJob (x2yJ >> Job.map Some) xs
    let rec mapFun x2y xs = mapfcm (fun x xs -> Cons (x2y x, mapFun x2y xs)) xs
  
    let amb ls rs = mapfc consf ls <|>* mapfc consf rs
  
    let rec mergeSwap ls rs = mapnc rs (fun l ls -> cons l (merge rs ls)) ls
    and merge ls rs = mergeSwap ls rs <|>* mergeSwap rs ls
  