anchor.diff:                  | Not cancel -> Cont.repeatUntil cancel body
   
           member x.Delay(f : unit -> Cont<'s, 'a>) =
  -            { run =
  -                state {
  -                    let! r = f().run
  -                    return r
  -                }
  -            }
  +            f()
  +//            { run =
  +//                state {
  +//                    return! f().run
  +//                }
  +//            }
   
   
           member x.Combine(l : Cont<'s, unit>, r : Cont<'s, 'a>) =
  
positive.code:         let d = delay r
          r := f(r)
          d
  
  type Future<'a> =
      | Later of (('a -> unit) -> IDisposable)
  
negative.code:             )
          )
  
  
  type Cont<'s, 'a> = { run : State<'s, Res<'s, 'a>> }
  
  and Res<'s, 'a> =
  