Real
This class defines a uniform interface for defining parsers for floating literals, independent of how whitespace should be handled after the literal.
Attributes
- Since:
4.0.0
- Note:
implementations of this class found within
Lexermay employ sharing and refine the non-finaldefs in this class intovalorlazy valwhen overriding.- Source:
- Real.scala
- Graph
- Supertypes
Members list
Value members
Abstract methods
This parser will parse a single real number literal, which is in binary form (base 2).
This parser will parse a single real number literal, which is in binary form (base 2).
Attributes
- Since:
4.0.0
- Todo:
examples
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.- Source:
- Real.scala
This parser will parse a single real number literal, which is in decimal form (base 10).
This parser will parse a single real number literal, which is in decimal form (base 10).
Attributes
- Since:
4.0.0
- Todo:
examples
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.- Source:
- Real.scala
This parser will parse a single real number literal, which is in hexadecimal form (base 16).
This parser will parse a single real number literal, which is in hexadecimal form (base 16).
Attributes
- Since:
4.0.0
- Todo:
examples
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.- Source:
- Real.scala
This parser will parse a single number literal, which may be in many different forms/bases depending on the configuration provided.
This parser will parse a single number literal, which may be in many different forms/bases depending on the configuration provided.
Attributes
- Since:
4.0.0
- Todo:
examples
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.- Source:
- Real.scala
This parser will parse a single real number literal, which is in octal form (base 8).
This parser will parse a single real number literal, which is in octal form (base 8).
Attributes
- Since:
4.0.0
- Todo:
examples
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.- Source:
- Real.scala
Concrete methods
This parser will behave the same as binary except it will round the result to the nearest valid Double.
This parser will behave the same as binary except it will round the result to the nearest valid Double.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.if the values are too big or too negatively big, they will be rounded to the corresponding infinity.
- Source:
- Real.scala
This parser will behave the same as binary except it will round the result to the nearest valid Float.
This parser will behave the same as binary except it will round the result to the nearest valid Float.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.if the values are too big or too negatively big, they will be rounded to the corresponding infinity.
- Source:
- Real.scala
This parser will behave the same as decimal except it will round the result to the nearest valid Double.
This parser will behave the same as decimal except it will round the result to the nearest valid Double.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.if the values are too big or too negatively big, they will be rounded to the corresponding infinity.
- Source:
- Real.scala
This parser will behave the same as decimal except it will round the result to the nearest valid Float.
This parser will behave the same as decimal except it will round the result to the nearest valid Float.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.if the values are too big or too negatively big, they will be rounded to the corresponding infinity.
- Source:
- Real.scala
This parser will behave the same as number except it will round the result to the nearest valid Double.
This parser will behave the same as number except it will round the result to the nearest valid Double.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.if the values are too big or too negatively big, they will be rounded to the corresponding infinity.
- Source:
- Real.scala
This parser will behave the same as number except it will round the result to the nearest valid Float.
This parser will behave the same as number except it will round the result to the nearest valid Float.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.if the values are too big or too negatively big, they will be rounded to the corresponding infinity.
- Source:
- Real.scala
This parser will behave the same as hexadecimal except it will round the result to the nearest valid Double.
This parser will behave the same as hexadecimal except it will round the result to the nearest valid Double.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.if the values are too big or too negatively big, they will be rounded to the corresponding infinity.
- Source:
- Real.scala
This parser will behave the same as hexadecimal except it will round the result to the nearest valid Float.
This parser will behave the same as hexadecimal except it will round the result to the nearest valid Float.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.if the values are too big or too negatively big, they will be rounded to the corresponding infinity.
- Source:
- Real.scala
This parser will behave the same as octal except it will round the result to the nearest valid Double.
This parser will behave the same as octal except it will round the result to the nearest valid Double.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.if the values are too big or too negatively big, they will be rounded to the corresponding infinity.
- Source:
- Real.scala
This parser will behave the same as octal except it will round the result to the nearest valid Float.
This parser will behave the same as octal except it will round the result to the nearest valid Float.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.if the values are too big or too negatively big, they will be rounded to the corresponding infinity.
- Source:
- Real.scala
Concrete fields
This parser will behave the same as binary except it will ensure that the resulting BigDecimal is within the maximum bounds of a double-precision IEEE 754 floating point value.
This parser will behave the same as binary except it will ensure that the resulting BigDecimal is within the maximum bounds of a double-precision IEEE 754 floating point value. The result is then converted to a Double.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.the validation is performed when the value is within the precision range, and rounding to the nearest exact value will still occur.
- Source:
- Real.scala
This parser will behave the same as binary except it will ensure that the resulting BigDecimal is an exactly represented double-precision IEEE 754 floating point value.
This parser will behave the same as binary except it will ensure that the resulting BigDecimal is an exactly represented double-precision IEEE 754 floating point value. The result is then converted to a Double.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.the number is considered exact when it can be losslessly represented in binary.
- Source:
- Real.scala
This parser will behave the same as binary except it will ensure that the resulting BigDecimal is an exactly represented single-precision IEEE 754 floating point value.
This parser will behave the same as binary except it will ensure that the resulting BigDecimal is an exactly represented single-precision IEEE 754 floating point value. The result is then converted to a Float.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.the number is considered exact when it can be losslessly represented in binary.
- Source:
- Real.scala
This parser will behave the same as binary except it will ensure that the resulting BigDecimal is within the maximum bounds of a single-precision IEEE 754 floating point value.
This parser will behave the same as binary except it will ensure that the resulting BigDecimal is within the maximum bounds of a single-precision IEEE 754 floating point value. The result is then converted to a Float.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.the validation is performed when the value is within the precision range, and rounding to the nearest exact value will still occur.
- Source:
- Real.scala
This parser will behave the same as decimal except it will ensure that the resulting BigDecimal is within the maximum bounds of a double-precision IEEE 754 floating point value.
This parser will behave the same as decimal except it will ensure that the resulting BigDecimal is within the maximum bounds of a double-precision IEEE 754 floating point value. The result is then converted to a Double.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.the validation is performed when the value is within the precision range, and rounding to the nearest exact value will still occur.
- Source:
- Real.scala
This parser will behave the same as decimal except it will ensure that the resulting BigDecimal is an exactly represented double-precision IEEE 754 floating point value.
This parser will behave the same as decimal except it will ensure that the resulting BigDecimal is an exactly represented double-precision IEEE 754 floating point value. The result is then converted to a Double.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.the number is considered exact when it can be losslessly represented in binary.
- Source:
- Real.scala
This parser will behave the same as decimal except it will ensure that the resulting BigDecimal is within the maximum bounds of a single-precision IEEE 754 floating point value.
This parser will behave the same as decimal except it will ensure that the resulting BigDecimal is within the maximum bounds of a single-precision IEEE 754 floating point value. The result is then converted to a Float.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.the number is considered exact when it can be losslessly represented in binary.
- Source:
- Real.scala
This parser will behave the same as decimal except it will ensure that the resulting BigDecimal is within the maximum bounds of a single-precision IEEE 754 floating point value.
This parser will behave the same as decimal except it will ensure that the resulting BigDecimal is within the maximum bounds of a single-precision IEEE 754 floating point value. The result is then converted to a Float.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.the validation is performed when the value is within the precision range, and rounding to the nearest exact value will still occur.
- Source:
- Real.scala
This parser will behave the same as number except it will ensure that the resulting BigDecimal is within the maximum bounds of a double-precision IEEE 754 floating point value.
This parser will behave the same as number except it will ensure that the resulting BigDecimal is within the maximum bounds of a double-precision IEEE 754 floating point value. The result is then converted to a Double.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.the validation is performed when the value is within the precision range, and rounding to the nearest exact value will still occur.
- Source:
- Real.scala
This parser will behave the same as number except it will ensure that the resulting BigDecimal is an exactly represented double-precision IEEE 754 floating point value.
This parser will behave the same as number except it will ensure that the resulting BigDecimal is an exactly represented double-precision IEEE 754 floating point value. The result is then converted to a Double.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.the number is considered exact when it can be losslessly represented in binary.
- Source:
- Real.scala
This parser will behave the same as number except it will ensure that the resulting BigDecimal is an exactly represented single-precision IEEE 754 floating point value.
This parser will behave the same as number except it will ensure that the resulting BigDecimal is an exactly represented single-precision IEEE 754 floating point value. The result is then converted to a Float.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.the number is considered exact when it can be losslessly represented in binary.
- Source:
- Real.scala
This parser will behave the same as number except it will ensure that the resulting BigDecimal is within the maximum bounds of a single-precision IEEE 754 floating point value.
This parser will behave the same as number except it will ensure that the resulting BigDecimal is within the maximum bounds of a single-precision IEEE 754 floating point value. The result is then converted to a Float.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.the validation is performed when the value is within the precision range, and rounding to the nearest exact value will still occur.
- Source:
- Real.scala
This parser will behave the same as hexadecimal except it will ensure that the resulting BigDecimal is within the maximum bounds of a double-precision IEEE 754 floating point value.
This parser will behave the same as hexadecimal except it will ensure that the resulting BigDecimal is within the maximum bounds of a double-precision IEEE 754 floating point value. The result is then converted to a Double.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.the validation is performed when the value is within the precision range, and rounding to the nearest exact value will still occur.
- Source:
- Real.scala
This parser will behave the same as hexadecimal except it will ensure that the resulting BigDecimal is an exactly represented double-precision IEEE 754 floating point value.
This parser will behave the same as hexadecimal except it will ensure that the resulting BigDecimal is an exactly represented double-precision IEEE 754 floating point value. The result is then converted to a Double.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.the number is considered exact when it can be losslessly represented in binary.
- Source:
- Real.scala
This parser will behave the same as hexadecimal except it will ensure that the resulting BigDecimal is an exactly represented single-precision IEEE 754 floating point value.
This parser will behave the same as hexadecimal except it will ensure that the resulting BigDecimal is an exactly represented single-precision IEEE 754 floating point value. The result is then converted to a Float.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.the number is considered exact when it can be losslessly represented in binary.
- Source:
- Real.scala
This parser will behave the same as hexadecimal except it will ensure that the resulting BigDecimal is within the maximum bounds of a single-precision IEEE 754 floating point value.
This parser will behave the same as hexadecimal except it will ensure that the resulting BigDecimal is within the maximum bounds of a single-precision IEEE 754 floating point value. The result is then converted to a Float.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.the validation is performed when the value is within the precision range, and rounding to the nearest exact value will still occur.
- Source:
- Real.scala
This parser will behave the same as octal except it will ensure that the resulting BigDecimal is within the maximum bounds of a double-precision IEEE 754 floating point value.
This parser will behave the same as octal except it will ensure that the resulting BigDecimal is within the maximum bounds of a double-precision IEEE 754 floating point value. The result is then converted to a Double.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.the validation is performed when the value is within the precision range, and rounding to the nearest exact value will still occur.
- Source:
- Real.scala
This parser will behave the same as octal except it will ensure that the resulting BigDecimal is an exactly represented double-precision IEEE 754 floating point value.
This parser will behave the same as octal except it will ensure that the resulting BigDecimal is an exactly represented double-precision IEEE 754 floating point value. The result is then converted to a Double.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.the number is considered exact when it can be losslessly represented in binary.
- Source:
- Real.scala
This parser will behave the same as octal except it will ensure that the resulting BigDecimal is an exactly represented single-precision IEEE 754 floating point value.
This parser will behave the same as octal except it will ensure that the resulting BigDecimal is an exactly represented single-precision IEEE 754 floating point value. The result is then converted to a Float.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.the number is considered exact when it can be losslessly represented in binary.
- Source:
- Real.scala
This parser will behave the same as octal except it will ensure that the resulting BigDecimal is within the maximum bounds of a single-precision IEEE 754 floating point value.
This parser will behave the same as octal except it will ensure that the resulting BigDecimal is within the maximum bounds of a single-precision IEEE 754 floating point value. The result is then converted to a Float.
Attributes
- Since:
4.0.0
- Note:
the exact behaviour of this parser is decided by the implementations given in
Lexer, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.the validation is performed when the value is within the precision range, and rounding to the nearest exact value will still occur.
- Source:
- Real.scala