anchor.diff:              // Force evaluation of the lazy value on a .NET ThreadPool thread.
               // The current (calling) thread is blocked until evaluation is complete or
               // the timeout duration elapses, whichever comes first.
  -
  -            // ThreadPool.RegisterWaitForSingleObject
  -            notImpl "Lazy.tryForce"
  +            
  +            /// The EventWaitHandle which signals that initialization of the value is complete.
  +            use initCompleted = new ManualResetEvent (false)
  +
  +            // 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 _ -> ()
  +                    
  +                    // Set the EventWaitHandle to signal that initialization of the value is complete.
  +                    // The return value is ignored here because there's not much we can do if the .Set()
  +                    // operation fails; raising an exception on a ThreadPool thread is generally not a great idea.
  +                    initCompleted.Set () |> ignore
  +                    )
  +                |> ThreadPool.QueueUserWorkItem
  +
  +            // If the callback couldn't be enqueued in the ThreadPool, return None instead of raising an exn.
  +            // TODO : Determine if this is the best strategy, or if it would be better to raise an exn instead.
  +            if not enqueuedInThreadPool then None
  +            else
  +                // Wait for the initialization to complete or the timeout period to elapse.
  +                if initCompleted.WaitOne timeout then
  +                    // Get the initialized value and return it.
  +                    Some lazyValue.Value
  +                else None
               
   
   /// Additional functional operators on options.
  
positive.code:         // Create a lazy value which uses the specified generator function.
          let lazyValue = Lazy.Create creator
  
          // Try to evaluate ("force") the thunk on a threadpool thread.
          let enqueuedInThreadPool =
              System.Threading.WaitCallback (fun _ ->
                  lazyValue.Force ()
                  |> ignore)
              |> ThreadPool.QueueUserWorkItem
  
          if enqueuedInThreadPool then
  
negative.code:     /// Forces evaluation of a lazily-initalized value in the background, using the .NET ThreadPool.
      [<CompiledName("ForceBackground")>]
      let forceBackground (lazyValue : Lazy<'T>) : unit =
          // 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
  
          // If the callback couldn't be enqueued, raise an exception.
  