anchor.diff:  
           // Evaluate the lazily-initialized value on a .NET ThreadPool thread.
           let enqueuedInThreadPool =
  -            System.Threading.WaitCallback (fun _ ->
  -                // Swallow any exception raised when initializing the value; it'll be cached
  -                // within the Lazy<_> and re-raised when the value is accessed later.
  -                try
  -                    // Force the value, ignoring the result
  -                    lazyValue.Force () |> ignore
  -                with _ -> ()
  -                )
  -            |> ThreadPool.QueueUserWorkItem
  +            ThreadPool.QueueUserWorkItem (forceCallback<'T>, lazyValue)
   
           if enqueuedInThreadPool then
               // Return the lazy value. The value will be evaluated in the threadpool,
  
positive.code:             // because that could lead to unexpected (and possibly dangerous) behavior like DoS vulnerabilities.
              lazy
                  failwith "The callback to create the lazily-evaluated value could not be enqueued in the .NET ThreadPool."
  
      /// <summary>
      /// Forces evaluation of a lazily-initialized value, if necessary.
  
negative.code:         else
              lazy (mapping (lazyValue1.Force ()) (lazyValue2.Force ()) (lazyValue3.Force ()))
  
      /// Callback delegate which forces evaluation of a Lazy<'T>.
      /// Meant to be used with ThreadPool.QueueUserWorkItem.
      let private forceCallback<'T> =
          System.Threading.WaitCallback (fun arg ->
              let lazyValue = arg :?> Lazy<'T>
  
              // Swallow any exception raised when initializing the value; it'll be cached
              // within the Lazy<_> and re-raised when the value is accessed later.
              try
                  // Force the value, ignoring the result
                  lazyValue.Force () |> ignore
              with _ -> ())
  
      /// <summary>Forces evaluation of a lazily-initalized value in the background, using the .NET ThreadPool.</summary>
      /// <param name="lazyValue"></param>
      [<CompiledName("ForceBackground")>]
      let forceBackground (lazyValue : Lazy<'T>) : unit =
          // Evaluate the lazily-initialized value on a .NET ThreadPool thread.
          let enqueuedInThreadPool =
              ThreadPool.QueueUserWorkItem (forceCallback<'T>, lazyValue)
  
          // If the callback couldn't be enqueued, raise an exception.
          if not enqueuedInThreadPool then
  