anchor.diff:                      if first then first <- false
                       else v :> obj |> f
                   )
  +
  +    type private T<'a>(inner : System.Threading.Tasks.Task<'a>) =
  +        member private x.Inner = inner
  +
  +        override x.GetHashCode() = inner.GetHashCode()
  +        override x.Equals o =
  +            match o with
  +                | :? T<'a> as o -> inner = o.Inner 
  +                | _ -> false
  +
  +        interface IObservable with
  +            member x.Subscribe f = 
  +                let mutable live = true
  +                let c (t : System.Threading.Tasks.Task<'a>) =
  +                    if live then 
  +                        f (t.Result :> obj)
  +
  +                inner.ContinueWith(System.Action<_>(c)) |> ignore
  +                { new IDisposable with member x.Dispose() = live <- false }
   
       type private TimePattern private() =
           inherit Pattern<Time>()
  
positive.code:                 m |> Proc.bind (fun v -> f(v).build self)
              }
  
          member x.Bind(m : ProcBuilder<'s, 'a, 'r>, f : 'a -> ProcBuilder<'s, 'b, 'r>) =
              { build = fun self ->
                  m.build self |> Proc.bind (fun v -> f(v).build self)
  
negative.code: 
          member x.Delay(f : unit -> Assertion<'s, 'x> * ProcBuilder<'s, 'a, 'r>) = f()
  
          member x.Delay(f : unit -> ProcBuilder<'s, 'a, 'r>) =
              { build = fun self ->
                  { run = state { return! f().build(self).run } }
              }
  
          member x.For(m : seq<'a>, f : 'a -> ProcBuilder<'s, unit, 'r>) : ProcBuilder<'s, unit, 'r> =
              { build = fun self ->
                  m |> Seq.map (fun v -> (f v).build self) |> Seq.fold Proc.append (Proc.value())
              }
  
          member x.For(m : Proc<'s, 'a>, f : 'a -> ProcBuilder<'s, unit, 'r>) : ProcBuilder<'s, unit, 'r> =
              { build = fun self -> Proc.foreach m (fun v -> f(v).build self) }
  
          member x.For(m : Event<'a>, f : 'a -> ProcBuilder<'s, unit, 'r>) : ProcBuilder<'s, unit, 'r> =
              { build = fun self -> Proc.foreach (Proc.ofEvent m) (fun v -> f(v).build self) }
  
  
          member x.While(guard : unit -> Proc<'s, bool>, body : ProcBuilder<'s, unit, 'r>) =
              { build = fun self -> Proc.repeatWhile (guard()) (body.build self) }
  
          member x.While(guard : unit -> bool, body : ProcBuilder<'s, unit, 'r>) =
              x.While((fun () -> { run = state { return guard() |> Finished } }), body)
  
          member x.While(guard : unit -> Event<bool>, body : ProcBuilder<'s, unit, 'r>) =
              x.While((fun () -> Proc.ofEvent (guard())), body)
  
  
  
          member x.Combine(l : ProcBuilder<'s, unit, 'r>, r : ProcBuilder<'s, 'a, 'r>) =
  