anchor.diff:  
     let locker continuation =
       let result =
  -      Monitor.Enter _queue
  -      try
  +      lock (_queue) (fun _ ->
           match _enter with
           | true ->
             _queue.Enqueue(continuation)
             false
           | false ->
             _enter <- true
  -          true
  -      finally
  -        Monitor.Exit _queue
  +          true)
       match result with
       | true -> continuation()
       | false -> ()
   
     let unlocker () =
       let result =
  -      Monitor.Enter _queue
  -      try
  +      lock (_queue) (fun _ ->
           match _queue.Count with
           | 0 ->
             _enter <- false
             None
           | _ ->
  -          Some (_queue.Dequeue())
  -      finally
  -        Monitor.Exit _queue
  +          Some (_queue.Dequeue()))
       match result with
       | Some continuation -> continuation()
       | None -> ()
  
positive.code:   /// Constructor.
    /// </summary>
    new () as this = {
      _async = Async.FromContinuations<'T>(fun (completed, caught, canceled) ->
        this._completed <- completed
        this._caught <- caught
        this._canceled <- canceled)
    }
  
    /// <summary>
  
negative.code: type private AsyncCompletionSource<'T> =
  
    [<DefaultValue>]
    val mutable private _value : 'T option
    [<DefaultValue>]
    val mutable private _exn : exn option
  
    [<DefaultValue>]
    val mutable private _completed : ('T -> unit) option
    [<DefaultValue>]
    val mutable private _caught : (exn -> unit) option
  
    val private _async : Async<'T>
  
  