anchor.diff:      terminal name
           (T (fun _ x ->
               (^TInt: (static member Parse:    string * NumberStyles * IFormatProvider -> ^TInt)
  -                (x.ToString(), NumberStyles.Integer, NumberFormatInfo.InvariantInfo))))
  -        unsignedRegex
  -
  +                (x.ToString(), NumberStyles.None, NumberFormatInfo.InvariantInfo))))
  +        unsignedIntRegex
  +
  +[<CompiledName("SignedIntRegex")>]
   /// A `Regex` that recognizes a series of decimal digits
   /// that might be prefixed with a minus sign "-".
   /// Leading zeros are accepted.
  -let signedRegex = (optional <| char '-') <&> unsignedRegex
  -
  -[<CompiledName("FSharpOnlyGenericSigned"); RequiresExplicitTypeArguments>]
  -/// Creates a designtimeFarkle that parses a signed decimal integer
  +let signedIntRegex = (optional <| char '-') <&> unsignedIntRegex
  +
  +[<CompiledName("FSharpOnlyGenericSigned"); RequiresExplicitTypeArguments; NoDynamicInvocation>]
  +/// Creates a designtime Farkle that parses a signed decimal integer
   /// into the desired number type. No bounds checking is performed.
   /// The type parameter must support the unary negation operator.
   /// Using this function from a language other than F# will throw an exception.
  
positive.code:         |> optional
      ]
  
  [<RequiresExplicitTypeArguments>]
  // We have exhausted all the cases, so let's make it private.
  let inline private genericReal< ^TReal when ^TReal: (static member Parse:    string * NumberStyles * IFormatProvider -> ^TReal)> name =
      terminal name
          (T (fun _ x ->
              (^TReal: (static member Parse:    string * NumberStyles * IFormatProvider -> ^TReal)
                  (x.ToString(), NumberStyles.AllowExponent ||| NumberStyles.Float, NumberFormatInfo.InvariantInfo))))
          realRegex
  
  [<CompiledName("Single")>]
  /// Creates a designtime Farkle that parses and returns
  /// a single-precision floating-point number. The number
  /// is expected to be written in scientific notation, with
  /// the decimal point symbol being the dot. Special values
  /// such as NaN or infinity are not recognized.
  let float32 name = genericReal<float32> name
  
  [<CompiledName("Double")>]
  /// Creates a designtime Farkle that parses and returns
  /// a single-precision floating-point number. The number
  /// is expected to be written in scientific notation, with
  /// the decimal point symbol being the dot. Special values
  /// such as NaN or infinity are not recognized.
  let float name = genericReal<float> name
  
  [<CompiledName("Decimal")>]
  /// Creates a designtime Farkle that parses and returns
  /// a single-precision floating-point number. The number
  /// is expected to be written in scientific notation, with
  /// the decimal point symbol being the dot.
  let decimal name = genericReal<decimal> name
  
  let private stringTransformer = T (fun _ span ->
      let span = span.Slice(1, span.Length - 2)
  
negative.code:         (T (fun _ x ->
              (^TInt: (static member Parse:    string * NumberStyles * IFormatProvider -> ^TInt)
                  (x.ToString(), NumberStyles.Integer, NumberFormatInfo.InvariantInfo))))
          signedIntRegex
  
  /// Creates a designtime Farkle that parses and returns a
  /// signed 32-bit signed integer. No bounds checking is performed.
  