anchor.diff:                  m |> Proc.bind (fun v -> f(v).build self)
               }
   
  +        member x.Bind(m : System.Threading.Tasks.Task<'a>, f : 'a -> ProcBuilder<'s, 'b, 'r>) =
  +            { build = fun self ->
  +                m |> Proc.ofTask |> 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)
  
positive.code:             append (bind body elements) (delay (fun () -> !self))
          )
  
      let repeat (inner : Proc<'s, unit>) =
          fix (fun self ->
              append inner (delay (fun () -> !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>) =
  