anchor.diff:  
       let track4
           (tracker : 'c -> 'a -> World -> 'c * bool)
  -        (plus : 'c -> 'b)
  +        (tranformer : 'c -> 'b)
           (state : 'c)
           (reactor : 'b Reactor) :
           'a Reactor =
  
positive.code:     let search p r = filter p ^^ head r
      let choose r = filter (fun o _ -> Option.isSome o) r
      let mapi r = augment (fun i _ -> i + 1) 0 r
      let max r = scan2 (fun u v _ -> if u < v then v else u) r
      let min r = scan2 (fun u v _ -> if v < u then v else u) r
      let distinct r = organize ^^ map (fun v _ -> fst v) ^^ choose r
      //let pairwise r = track (fun o _ -> match o with Some v -> (v, true) | None ->  )
  
      (* Map Combinators *)
  
  
negative.code:         Reactor.make reactor.ReactAddress handler reactor.Unsubscriber reactor.World
  
      let augment f s r = track (fun b w -> (f b w, true)) s r
      let scan4 f g s r = track4 (fun c a w -> (f c a w, true)) g s r
      let scan2 f r = track2 (fun a a2 w -> (f a a2 w, true)) r
      let scan f s r = scan4 f id s r
  
      (* Advanced Combinators *)
  
      let inline average (reactor : 'a Reactor) : 'a Reactor =
          scan4
              (fun (_ : 'a, n : 'a, d : 'a) a _ ->
                  let n = n + a
                  let d = d + GenericOne
                  (n / d, n, d))
              Triple.fst
              (GenericZero, GenericZero, GenericZero)
              reactor
  
      let organize (reactor : ('a option * ('a Set)) Reactor) : 'a Reactor =
          scan
              (fun (_, s) a _ ->
                  if Set.contains a s
                  then (None, s)
                  else (Some a, Set.add a s))
              (None, Set.empty)
              reactor
  
      let group (reactor : ('a * bool * ('a Set)) Reactor) : 'a Reactor =
          scan
              (fun (_, _, s) a _ ->
                  if Set.contains a s
                  then (a, false, s)
                  else (a, true, Set.add a s))
              (Unchecked.defaultof<'a>, false, Set.empty)
              reactor
      
      let pairwise (r : ('a * 'a) Reactor) : 'a Reactor =
          track4
              (fun (o, _) a _ -> ((o, a), Option.isSome o))
              (fun (o, c) -> (Option.get o, c))
              (None, Unchecked.defaultof<'a>)
              r
  
      let inline sum r = scan2 (fun m n _ -> m + n) r
      let take n r = track (fun m _ -> (m + 1, m < n)) 0 r
  