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: // A string prefixed by four spaces will be replaced in the future with
  // a ReadOnlySpan of characters.
  
  /// A `Regex` that recognizes a series of decimal digits.
  /// Leading zeros are accepted.
  // Seriously though, why not? Looking at you, JSON!
  let unsignedRegex = Number |> chars |> atLeast 1
  
  [<CompiledName("FSharpOnlyGenericUnsigned"); RequiresExplicitTypeArguments>]
  /// Creates a designtimeFarkle that parses an unsigned decimal integer
  /// into the desired number type. No bounds checking is performed.
  /// Using this function from a language other than F# will throw an exception.
  
negative.code:         |> optional
      ]
  
  [<CompiledName("SignedRealRegex")>]
  /// Like `unsignedRealRegex`, but with an optional
  /// sign in the beginning being allowed.
  let signedRealRegex = (optional <| char '-') <&> unsignedRealRegex
  
  [<CompiledName("FSharpOnlyGenericReal"); RequiresExplicitTypeArguments; NoDynamicInvocation>]
  /// Creates a designtime Farkle that parses a real number
  /// into the desired number type. No bounds checking is performed.
  /// Using this function from a language other than F# will throw an exception.
  let inline genericReal< ^TReal when ^TReal: (static member Parse:    string * NumberStyles * IFormatProvider -> ^TReal)> allowSign name =
      let regex =
          if allowSign then
              signedRealRegex
          else
              unsignedRealRegex
      terminal name
          (T (fun _ x ->
              (^TReal: (static member Parse:    string * NumberStyles * IFormatProvider -> ^TReal)
                  (x.ToString(), NumberStyles.Float, NumberFormatInfo.InvariantInfo))))
          regex
  
  [<CompiledName("Single")>]
  /// Creates a designtime Farkle that parses and returns
  /// a signed 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> true name
  
  [<CompiledName("Double")>]
  /// Creates a designtime Farkle that parses and returns
  /// a signed double-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> true name
  
  [<CompiledName("Decimal")>]
  /// Creates a designtime Farkle that parses and returns
  /// a signed decimal 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> true name
  
  let private stringTransformer = T (fun _ span ->
      let span = span.Slice(1, span.Length - 2)
  