anchor.diff:      // integrate all steps
       let res = 
           delta 
  -            |> SF.integrate [] (fun l e -> l @ e)
  +            |> SF.fold [] (fun l e -> l @ e)
               ||> List.rev
               
   
  -    let withCancel =
  -        SF.switchTrue (SF.latest cancel)
  -            SF.stop
  -            (SF.arr id)
  +    let cts = new CancellationTokenSource()
  +
   
       // start the sf as task
  -    (res >>> withCancel) |> SF.reactimate () (printfn "out: %A") |> Async.Start
  +    res >>> SF.withCancellation cts.Token
  +        |> SF.reactimate () (printfn "out: %A") |> Async.Start
   
       
   
  
positive.code:                     nv, switch gc onEvent nc
          )
  
      let rec integrate (seed : 's) (acc : 's -> 'a -> 's) (m : sf<'x, 'a>) =
          custom m.dependencies (fun _ ctx x ->
              let (mv,mc) = m.run ctx x
              let s = acc seed mv
              s, integrate s acc mc
          )
  
      let rec switchTrue (guard : sf<'a, bool>) (ifTrue : sf<'a, 'b>) (ifFalse : sf<'a, 'b>) =
          let deps = List.concat [guard.dependencies; ifTrue.dependencies; ifFalse.dependencies]
          custom deps (fun _ ctx a ->
              let (gv, gc) = guard.run ctx a
              if gv then
                  let (ev, ec) = ifTrue.run ctx a
                  ev, switchTrue gc ec ifFalse
  
              else
                  let (nv, nc) = ifFalse.run ctx a
                  nv, switchTrue gc ifTrue nc
          )
   
  
  
      let latest (m : IMod<'a>) : sf<'x, 'a> =
          custom [] (fun self ctx _ ->
  
negative.code: 
  let test () = 
      let step = Mod.init 0
  
      // whenever we have a step use it otherwise step by 0
      let delta = 
  