anchor.diff:                  async { match x.scanArrivals(f) with
                           | None -> 
                               // Deschedule and wait for a message. When it comes, rescan the arrivals
  -                            let! ok = AsyncHelpers.awaitEither waitOneNoTimeout timeoutAsync
  +                            let! ok = AsyncHelpers.awaitEither waitOneNoTimeoutOrCancellation timeoutAsync
                               match ok with
                               | Choice1Of2 true -> 
                                   return! scan timeoutAsync timeoutCts
                               | Choice1Of2 false ->
  -                                return failwith "should not happen - waitOneNoTimeout always returns true"
  +                                return failwith "should not happen - waitOneNoTimeoutOrCancellation always returns true"
                               | Choice2Of2 () ->
                                   lock syncRoot (fun () -> 
  -                                    // Cancel the outstanding wait for messages installed by waitOneNoTimeout
  +                                    // 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, waitOneNoTimeout
  +                                    // 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.
  
positive.code:     [<AutoSerializable(false)>]
      [<CompiledName("FSharpMailboxProcessor`1")>]
      type MailboxProcessor<'Msg>(initial, ?cancellationToken) =
          let cancellationToken = defaultArg cancellationToken Async.DefaultCancellationToken
          let mailbox = new Mailbox<'Msg>()
          let mutable defaultTimeout = Threading.Timeout.Infinite
          let mutable started = false
          let errorEvent = new Event<System.Exception>()
  
negative.code:                 ()
              pulse
                  
          let waitOneNoTimeoutOrCancellation = 
              unprotectedPrimitive (fun ({ aux = aux } as args) -> 
                  match savedCont with 
                  | None -> 
  