anchor.diff:                  else
                       this.Array.[this.Offset + index] <- value
   
  -    /// Type abbreviation for System.Collections.Generic.Queue.
  -    type ResizeQueue<'T> = System.Collections.Generic.Queue<'T>
  +
  +    (* Operators *)
   
       /// Physical equality operator.
       let inline (===) (x : 'T) y =
  
positive.code:         | Some x ->
              x :: list
  
      /// Swaps the values of a tuple so their order is reversed.
      [<CompiledName("Swap")>]
      let inline swap (x : 'T, y : 'U) =
  
negative.code:     [<CompiledName("Xnor")>]
      let inline xnor (p : bool) (q : bool) =
          // OPTIMIZE : Use inline IL to emit 'xor, not' instead of 'ceq, ldc.i4.0, ceq, not'
          not (p <> q)
  
      /// Intercepts a value within a pipeline. The value is applied to a given
      /// function, then returned so it can continue through the pipeline.
      /// This function is primarily useful for debugging pipelines.
      [<CompiledName("Tap")>]
      let tap (action : 'T -> unit) (value : 'T) : 'T =
          action value
          value
  
      /// Creates a 'lazy' value whose value is immediately available; that is,
      /// it does not need to execute a thunk to compute it's value.
      [<CompiledName("NotLazy")>]
      let inline notlazy (value : 'T) =
          Lazy.CreateFromValue value
  
  
      (* General functions *)
  
      /// Attempt to execute the function as a mutual-exclusion region using
      /// the input value as a lock. If the lock cannot be entered within a specified
  