anchor.diff:  
       [<Sealed>]
       [<AutoSerializable(false)>]        
  -    type Mailbox<'Msg>() =  
  +    type Mailbox<'Msg>(cancellationSupported: bool) =  
           let mutable inboxStore  = null 
           let mutable arrivals = new Queue<'Msg>()
           let syncRoot = arrivals
  
positive.code:                        }
              let rec scanNoTimeout () =
                  async { match x.scanArrivals(f) with
                          |   None -> let! ok = waitOneNoTimeout
                                      if ok then
                                          return! scanNoTimeout()
                                      else
  
negative.code:                 async { match x.scanArrivals(f) with
                          | None -> 
                              // Deschedule and wait for a message. When it comes, rescan the arrivals
                              let! ok = AsyncHelpers.awaitEither waitOneNoTimeoutOrCancellation timeoutAsync
                              match ok with
                              | Choice1Of2 true -> 
                                  return! scan timeoutAsync timeoutCts
                              | Choice1Of2 false ->
                                  return failwith "should not happen - waitOneNoTimeoutOrCancellation always returns true"
                              | Choice2Of2 () ->
                                  lock syncRoot (fun () -> 
                                      // Cancel the outstanding wait for messages installed by waitOneWithCancellation
                                      //
                                      // HERE BE DRAGONS. This is bestowed on us because we only support
                                      // a single mailbox reader at any one time.
                                      // If awaitEither returned control because timeoutAsync has terminated, waitOneNoTimeoutOrCancellation
                                      // might still be in-flight. In practical terms, it means that the push-to-async-result-cell 
                                      // continuation that awaitEither registered on it is still pending, i.e. it is still in savedCont.
                                      // That continuation is a no-op now, but it is still a registered reader for arriving messages.
  