anchor.diff:              mapping lazyValue1.Value lazyValue2.Value lazyValue3.Value
               |> Lazy<'T>.CreateFromValue
           else
  -            lazy (mapping (lazyValue1.Force ()) (lazyValue2.Force ()) (lazyValue3.Force ()))
  +            lazy (mapping lazyValue1.Value lazyValue2.Value lazyValue3.Value)
   
       /// <summary></summary>
       /// <param name="binding"></param>
  
positive.code:     /// <returns></returns>
      [<CompiledName("Map2")>]
      let map2 (mapping : 'T1 -> 'T2 -> 'U) (lazyValue1 : Lazy<'T1>) (lazyValue2 : Lazy<'T2>) : Lazy<'U> =
          // Preconditions
          checkNonNull "lazyValue1" lazyValue1
          checkNonNull "lazyValue2" lazyValue2
  
negative.code:         else None
  
      /// <summary>Transforms a lazily-initialized value by applying it to the given mapping function.</summary>
      /// <param name="mapping">A mapping function applied to the lazily-initialized value to produce a new value.</param>
      /// <param name="lazyValue">A lazily-initialized value.</param>
      /// <returns>
      /// The lazily-evaluated result of applying <paramref name="mapping"/> to <paramref name="lazyValue"/>.
      /// </returns>
      /// <c>mapImmediately</c> differs from <c>map</c> in that, if the lazily-initialized value
      /// has already been evaluated, the mapping function is immediately applied to the value.
      /// This distinction matters primarily when the mapping function has side effects (such as raising an exception),
      /// since they will occur at different times depending on whether the value has been initialized.
      /// It is recommended to use <c>map</c> for such cases to ensure side effects are handled uniformly.
      /// </remarks>
      [<CompiledName("Map")>]
      let map (mapping : 'T -> 'U) (lazyValue : Lazy<'T>) : Lazy<'U> =
          // Preconditions
          checkNonNull "lazyValue" lazyValue
  
          lazy (mapping lazyValue.Value)
  
      /// <summary>
      /// Transforms a lazily-initialized value by applying it to the given mapping function.
      /// </summary>
      /// <param name="mapping">A mapping function applied to the lazily-initialized value to produce a new value.</param>
      /// <param name="lazyValue">A lazily-initialized value.</param>
      /// <returns>
      /// The lazily-evaluated result of applying <paramref name="mapping"/> to <paramref name="lazyValue"/>.
      /// </returns>
      /// <remarks>
      /// <c>mapImmediately</c> differs from <c>map</c> in that, if the lazily-initialized value
      /// has already been evaluated, the mapping function is immediately applied to the value.
      /// This distinction matters primarily when the mapping function has side effects (such as raising an exception),
      /// since they will occur at different times depending on whether the value has been initialized.
      /// It is recommended to use <c>map</c> for such cases to ensure side effects are handled uniformly.
      /// </remarks>
      [<CompiledName("MapImmediately")>]
      let mapImmediately (mapping : 'T -> 'U) (lazyValue : Lazy<'T>) : Lazy<'U> =
          // Preconditions
          checkNonNull "lazyValue" lazyValue
  
          // Apply 'mapping' eagerly if the value has already been initialized.
          if lazyValue.IsValueCreated then
              lazyValue.Value
              |> mapping
              |> Lazy<'T>.CreateFromValue
          else
              lazy (mapping lazyValue.Value)
  
      /// <summary>Transforms two (2) lazily-initialized values by applying them to the given mapping function.</summary>
      /// <param name="mapping"></param>
  