anchor.diff:          |> 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 =
  +[<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.AllowExponent ||| NumberStyles.Float, NumberFormatInfo.InvariantInfo))))
  -        realRegex
  +                (x.ToString(), NumberStyles.Float, NumberFormatInfo.InvariantInfo))))
  +        regex
   
   [<CompiledName("Single")>]
   /// Creates a designtime Farkle that parses and returns
  -/// a single-precision floating-point number. The number
  +/// 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> name
  +let float32 name = genericReal<float32> true name
   
   [<CompiledName("Double")>]
   /// Creates a designtime Farkle that parses and returns
  -/// a single-precision floating-point number. The number
  +/// 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> name
  +let float name = genericReal<float> true name
   
   [<CompiledName("Decimal")>]
   /// Creates a designtime Farkle that parses and returns
  -/// a single-precision floating-point number. The number
  +/// 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> name
  +let decimal name = genericReal<decimal> true name
   
   let private stringTransformer = T (fun _ span ->
       let span = span.Slice(1, span.Length - 2)
  
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: /// signed 64-bit unsigned integer. No bounds checking is performed.
  let uint64 name = genericUnsigned<uint64> name
  
  [<CompiledName("UnsignedRealRegex")>]
  /// A `Regex` that recognizes an unsigned real number.
  /// The number is expected to be written in scientific
  /// notation, with the decimal point symbol being the dot.
  /// Numbers before or after the dot are optional, but they
  /// must exist in at least one of the two places.
  let unsignedRealRegex =
      let numberStar = chars Number |> star
      let atLeastOneNumber = chars Number <&> numberStar
      let dotOptional = char '.' |> optional
      concat [
          choice [
              // There has to be at least one digit
              // either before or after the dot.
  