anchor.diff:      [<AutoSerializable(false)>]
       [<CompiledName("FSharpMailboxProcessor`1")>]
       type MailboxProcessor<'Msg>(initial, ?cancellationToken) =
  +        let cancellationSupported = cancellationToken.IsSome
           let cancellationToken = defaultArg cancellationToken Async.DefaultCancellationToken
  -        let mailbox = new Mailbox<'Msg>()
  +        let mailbox = new Mailbox<'Msg>(cancellationSupported)
           let mutable defaultTimeout = Threading.Timeout.Infinite
           let mutable started = false
           let errorEvent = new Event<System.Exception>()
  
positive.code:                 | Some _ -> 
                      failwith "multiple waiting reader continuations for mailbox")
  
          let waitOne(timeout) = 
              if timeout < 0  then 
                  waitOneNoTimeout
              else 
                  ensurePulse().AsyncWaitOne(millisecondsTimeout=timeout)
  
          member x.inbox = 
              match inboxStore with 
  
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.
  