anchor.diff:      let errorEvent = Event<exn>()
       let mailbox = LinkedList<'T>()
       let mutable savedCont = None
  -    
  +
  +    let startAsync a =
  +        Async.Start(a, ?cancellationToken = token)
  +
  +    let resume() =
  +        match savedCont with
  +        | None -> ()
  +        | Some c ->
  +            savedCont <- None
  +            c |> startAsync
  +
  +    do  match token with
  +        | Some ct -> 
  +            ct.Register(fun () -> resume()) |> ignore
  +        | None -> ()
  +
       let dequeue() =
           let f = mailbox.First.Value
           mailbox.RemoveFirst()
           f
   
  +    [<Inline>]
       member this.Error = errorEvent.Publish
  -
  +    [<Inline>]
       member this.add_Error handler = this.Error.AddHandler handler
  +    [<Inline>]
       member this.remove_Error handler = this.Error.RemoveHandler handler
  +
  +    // TODO : DefaultTimeout
   
       member this.Start() =
           if started then
  
positive.code:             async {
                  try do! initial (As<MailboxProcessor<'T>> this)
                  with err -> errorEvent.Trigger err
              } |> Async.Start
  
      static member Start(initial, ?token: CancellationToken) =
          let mb = new MailboxProcessor<'T>(initial)
          mb.Start()
          mb
  
      member this.Post(msg: 'T) =
          mailbox.AddLast msg |> ignore   
          match savedCont with
          | None -> ()
          | Some c ->
              savedCont <- None
              c |> Async.Start
  
      member this.Receive(?timeout: int) =
          Async.FromContinuations <| fun (ok, _, _) ->
              if mailbox.First = null then
                  savedCont <- Some <| async { dequeue() |> ok }
              else dequeue() |> ok
                
      member this.CurrentQueueLength = mailbox.Count
  
      member this.PostAndAsyncReply(msgf: AsyncReplyChannel<'R> -> 'T, ?timeout: int) : Async<'R> =
          Async.FromContinuations <| fun (ok, _, _) ->
              ChannelProxy ok |> As |> msgf |> this.Post
  
      member this.Scan(scanner, ?timeout: int) =
          let scanInbox() =
              let mutable m = mailbox.First
              let mutable found = None
              while m <> null do 
                  match scanner m.Value with
                  | None ->
                      m <- m.Next
                  | _ as res ->
                      mailbox.Remove m
                      m <- null
                      found <- res
              found
  
          let rec scanNext ok =
              savedCont <- Some <| async {
                  match scanner mailbox.First.Value with
                  | None -> scanNext ok
                  | Some c ->
                      mailbox.RemoveFirst()
                      let! res = c
                      ok res
              }
  
          async {
              match scanInbox() with
              | Some res -> return! res
              | _ -> return! Async.FromContinuations <| fun (ok, _, _) -> scanNext ok
          }
  
negative.code: open IntelliFactory.WebSharper
  open System.Threading
  
  [<Proxy(typeof<AsyncReplyChannel<_>>)>]
  type private ChannelProxy<'T> =
      [<Inline "$this($res)">]
      member this.Reply(res: 'T) = X<unit>
  
  [<Proxy(typeof<System.TimeoutException>)>]
  type TimeoutExceptionProxy =
      [<Inline "new Error(\"TimeoutException\")">]
      new () = {}
  
  [<JavaScript>]
  [<Proxy(typeof<MailboxProcessor<_>>)>]
  