anchor.diff:  
   /// Functional operators on enumerations.
   [<RequireQualifiedAccess; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  -module internal Enum =
  +module Enum =
       //
       let values<'Enum, 'T when 'Enum : enum<'T>> () =
  -        typeof<'Enum> |> System.Enum.GetValues :?> 'Enum[]
  +        typeof<'Enum>
  +        |> System.Enum.GetValues
  +        :?> 'Enum[]
  +
  +
  +/// Functional operators on lazily-initialized values.
  +[<RequireQualifiedAccess; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  +module Lazy =
  +    //
  +    let [<NoDynamicInvocation>] inline force (lazyValue : Lazy<'T>) =
  +        lazyValue.Force ()
  +
  +    //
  +    let [<NoDynamicInvocation>] inline value (lazyValue : Lazy<'T>) =
  +        lazyValue.Value
  +
  +    //
  +    let tryGetValue (lazyValue : Lazy<'T>) =
  +        if lazyValue.IsValueCreated then
  +            Some lazyValue.Value
  +        else None
   
   
   /// Additional functional operators on strings.
   [<RequireQualifiedAccess; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  -module internal String =
  +module String =
       /// The empty string literal.
       let [<Literal>] empty = ""
   
  
positive.code: (*
  /// Additional functional operators on Choice<_,_> values.
  [<RequireQualifiedAccess; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  module internal Choice =
      //
      let map (mapping : 'T -> 'U) = function
          | Choice1Of2 result -> Choice1Of2 (mapping result)
  
negative.code: 
  /// Additional functional operators on options.
  [<RequireQualifiedAccess; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  module Option =
      open System
  
      /// Creates an F# option from an instance of a reference type.
      /// If the reference is null, returns None; otherwise, (Some value).
      let [<NoDynamicInvocation>] inline ofNull (value : 'T) =
          if isNull value then None else Some value
  
      /// Creates an instance of a type with the 'null' constraint from an F# option value for that type.
      /// If the option value is None, returns 'null'. Otherwise, returns the reference contained in the Some.
      let [<NoDynamicInvocation>] inline toNull (value : 'T option) =
          match value with Some x -> x | None -> null
  
      /// Creates an F# option from a nullable value.
      let [<NoDynamicInvocation>] inline ofNullable (arg : Nullable<'T>) =
          if arg.HasValue then Some arg.Value else None
  
      /// Creates a nullable value from an F# option.
      let [<NoDynamicInvocation>] inline toNullable (value : 'T option) =
          match value with
          | Some x -> Nullable<_> x
          | None -> Nullable<_> ()
  
      /// Creates an F# option from a value 'x'.
      /// When the specified condition is true, returns Some x; otherwise, None.
      let [<NoDynamicInvocation>] inline ofCondition cond value =
          if cond then Some value else None
  
      /// Chains two option values together.
      /// If the first value is Some, it is returned; otherwise, the second value is returned.
      /// Similar to the (??) operator in C#.
      let [<NoDynamicInvocation>] inline coalesce (x : 'T option) (y : 'T option) =
          match x with
          | (Some _) -> x
  