Integer
This class defines a uniform interface for defining parsers for integer literals, independent of how whitespace should be handled after the literal or whether the literal should allow for negative numbers.
Attributes
- Since:
4.0.0
- Note:
implementations of this class found within
Lexer
may employ sharing and refine the non-finaldef
s in this class intoval
orlazy val
when overriding.- Source:
- Integer.scala
- Graph
- Supertypes
Members list
Value members
Abstract methods
This parser will parse a single integer literal, which is in binary form (base 2).
This parser will parse a single integer literal, which is in binary form (base 2).
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.- Example:
// using signed integers and standard numeric prefixes scala> binary.parse("0b1011") val res0 = Success(BigInt(11)) scala> binary.parse("10") val res2 = Failure(..) // no binary prefix scala> binary.parse("0b22") val res3 = Failure(..) // no other digits
- Source:
- Integer.scala
This parser will parse a single integer literal, which is in decimal form (base 10).
This parser will parse a single integer literal, which is in decimal form (base 10).
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.- Example:
// using signed integers and standard numeric prefixes scala> decimal.parse("103") val res0 = Success(BigInt(103)) scala> decimal.parse("9999999999999999999999999999999999") val res1 = Success(BigInt(9999999999999999999999999999999999)) scala> decimal.parse("1f") val res2 = Failure(..) // no hexadecimal digits supported scala> decimal.parse("0xff") val res3 = Failure(..) // no hexadecimal literals either
- Source:
- Integer.scala
This parser will parse a single integer literal, which is in hexadecimal form (base 16).
This parser will parse a single integer literal, which is in hexadecimal form (base 16).
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.- Example:
// using signed integers and standard numeric prefixes scala> hexadecimal.parse("0x103") val res0 = Success(BigInt(259)) scala> hexadecimal.parse("0x9999999999999999999999999999999999") val res1 = Success(BigInt(0x9999999999999999999999999999999999)) scala> hexadecimal.parse("1f") val res2 = Failure(..) // no hexadecimal prefix scala> hexadecimal.parse("0xff") val res3 = Success(BigInt(0xff))
- Source:
- Integer.scala
This parser will parse a single integer literal, which can be in many forms and bases depending on the configuration.
This parser will parse a single integer literal, which can be in many forms and bases depending on the configuration.
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.- Example:
// using signed integers and standard numeric prefixes (and octal, binary, and decimal on) scala> number.parse("0b1011") val res0 = Success(BigInt(11)) scala> number.parse("0o103") val res1 = Success(BigInt(43)) scala> number.parse("10") val res2 = Success(10) scala> number.parse("0xff") val res1 = Failure(..) // configuration specified above does not support hex
- Source:
- Integer.scala
This parser will parse a single integer literal, which is in octal form (base 8).
This parser will parse a single integer literal, which is in octal form (base 8).
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.- Example:
// using signed integers and standard numeric prefixes scala> octal.parse("0o103") val res0 = Success(BigInt(43)) scala> octal.parse("1f") val res2 = Failure(..) // no hexadecimal digits supported scala> octal.parse("0xff") val res3 = Failure(..) // no hexadecimal literals either
- Source:
- Integer.scala
Concrete methods
This parser will behave the same as binary
except it will ensure that the resulting BigInt
is a valid 16-bit
number.
This parser will behave the same as binary
except it will ensure that the resulting BigInt
is a valid 16-bit
number. The resulting number will be converted to the given
type T
, which must be able to losslessly store the parsed
value; this is enforced by the constraint on the type. This
accounts for unsignedness when necessary.
Attributes
- T
the desired type of the result, defaulting to
Short
- 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.- Source:
- Integer.scala
This parser will behave the same as binary
except it will ensure that the resulting BigInt
is a valid 32-bit
number.
This parser will behave the same as binary
except it will ensure that the resulting BigInt
is a valid 32-bit
number. The resulting number will be converted to the given
type T
, which must be able to losslessly store the parsed
value; this is enforced by the constraint on the type. This
accounts for unsignedness when necessary.
Attributes
- T
the desired type of the result, defaulting to
Int
- 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.- Source:
- Integer.scala
This parser will behave the same as binary
except it will ensure that the resulting BigInt
is a valid 64-bit
number.
This parser will behave the same as binary
except it will ensure that the resulting BigInt
is a valid 64-bit
number. The resulting number will be converted to the given
type T
, which must be able to losslessly store the parsed
value; this is enforced by the constraint on the type. This
accounts for unsignedness when necessary.
Attributes
- T
the desired type of the result, defaulting to
Long
- 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.- Source:
- Integer.scala
This parser will behave the same as binary
except it will ensure that the resulting BigInt
is a valid 8-bit
number.
This parser will behave the same as binary
except it will ensure that the resulting BigInt
is a valid 8-bit
number. The resulting number will be converted to the given
type T
, which must be able to losslessly store the parsed
value; this is enforced by the constraint on the type. This
accounts for unsignedness when necessary.
Attributes
- T
the desired type of the result, defaulting to
Byte
- 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.- Source:
- Integer.scala
This parser will behave the same as decimal
except it will ensure that the resulting BigInt
is a valid 16-bit
number.
This parser will behave the same as decimal
except it will ensure that the resulting BigInt
is a valid 16-bit
number. The resulting number will be converted to the given
type T
, which must be able to losslessly store the parsed
value; this is enforced by the constraint on the type. This
accounts for unsignedness when necessary.
Attributes
- T
the desired type of the result, defaulting to
Short
- 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.- Source:
- Integer.scala
This parser will behave the same as decimal
except it will ensure that the resulting BigInt
is a valid 32-bit
number.
This parser will behave the same as decimal
except it will ensure that the resulting BigInt
is a valid 32-bit
number. The resulting number will be converted to the given
type T
, which must be able to losslessly store the parsed
value; this is enforced by the constraint on the type. This
accounts for unsignedness when necessary.
Attributes
- T
the desired type of the result, defaulting to
Int
- 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.- Source:
- Integer.scala
This parser will behave the same as decimal
except it will ensure that the resulting BigInt
is a valid 64-bit
number.
This parser will behave the same as decimal
except it will ensure that the resulting BigInt
is a valid 64-bit
number. The resulting number will be converted to the given
type T
, which must be able to losslessly store the parsed
value; this is enforced by the constraint on the type. This
accounts for unsignedness when necessary.
Attributes
- T
the desired type of the result, defaulting to
Long
- 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.- Source:
- Integer.scala
This parser will behave the same as decimal
except it will ensure that the resulting BigInt
is a valid 8-bit
number.
This parser will behave the same as decimal
except it will ensure that the resulting BigInt
is a valid 8-bit
number. The resulting number will be converted to the given
type T
, which must be able to losslessly store the parsed
value; this is enforced by the constraint on the type. This
accounts for unsignedness when necessary.
Attributes
- T
the desired type of the result, defaulting to
Byte
- 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.- Source:
- Integer.scala
This parser will behave the same as hexadecimal
except it will ensure that the resulting BigInt
is a valid 16-bit
number.
This parser will behave the same as hexadecimal
except it will ensure that the resulting BigInt
is a valid 16-bit
number. The resulting number will be converted to the given
type T
, which must be able to losslessly store the parsed
value; this is enforced by the constraint on the type. This
accounts for unsignedness when necessary.
Attributes
- T
the desired type of the result, defaulting to
Short
- 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.- Source:
- Integer.scala
This parser will behave the same as hexadecimal
except it will ensure that the resulting BigInt
is a valid 32-bit
number.
This parser will behave the same as hexadecimal
except it will ensure that the resulting BigInt
is a valid 32-bit
number. The resulting number will be converted to the given
type T
, which must be able to losslessly store the parsed
value; this is enforced by the constraint on the type. This
accounts for unsignedness when necessary.
Attributes
- T
the desired type of the result, defaulting to
Int
- 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.- Source:
- Integer.scala
This parser will behave the same as hexadecimal
except it will ensure that the resulting BigInt
is a valid 64-bit
number.
This parser will behave the same as hexadecimal
except it will ensure that the resulting BigInt
is a valid 64-bit
number. The resulting number will be converted to the given
type T
, which must be able to losslessly store the parsed
value; this is enforced by the constraint on the type. This
accounts for unsignedness when necessary.
Attributes
- T
the desired type of the result, defaulting to
Long
- 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.- Source:
- Integer.scala
This parser will behave the same as hexadecimal
except it will ensure that the resulting BigInt
is a valid 8-bit
number.
This parser will behave the same as hexadecimal
except it will ensure that the resulting BigInt
is a valid 8-bit
number. The resulting number will be converted to the given
type T
, which must be able to losslessly store the parsed
value; this is enforced by the constraint on the type. This
accounts for unsignedness when necessary.
Attributes
- T
the desired type of the result, defaulting to
Byte
- 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.- Source:
- Integer.scala
This parser will behave the same as number
except it will ensure that the resulting BigInt
is a valid 16-bit
number.
This parser will behave the same as number
except it will ensure that the resulting BigInt
is a valid 16-bit
number. The resulting number will be converted to the given
type T
, which must be able to losslessly store the parsed
value; this is enforced by the constraint on the type. This
accounts for unsignedness when necessary.
Attributes
- T
the desired type of the result, defaulting to
Short
- 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.- Source:
- Integer.scala
This parser will behave the same as number
except it will ensure that the resulting BigInt
is a valid 32-bit
number.
This parser will behave the same as number
except it will ensure that the resulting BigInt
is a valid 32-bit
number. The resulting number will be converted to the given
type T
, which must be able to losslessly store the parsed
value; this is enforced by the constraint on the type. This
accounts for unsignedness when necessary.
Attributes
- T
the desired type of the result, defaulting to
Int
- 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.- Source:
- Integer.scala
This parser will behave the same as number
except it will ensure that the resulting BigInt
is a valid 64-bit
number.
This parser will behave the same as number
except it will ensure that the resulting BigInt
is a valid 64-bit
number. The resulting number will be converted to the given
type T
, which must be able to losslessly store the parsed
value; this is enforced by the constraint on the type. This
accounts for unsignedness when necessary.
Attributes
- T
the desired type of the result, defaulting to
Long
- 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.- Source:
- Integer.scala
This parser will behave the same as number
except it will ensure that the resulting BigInt
is a valid 8-bit
number.
This parser will behave the same as number
except it will ensure that the resulting BigInt
is a valid 8-bit
number. The resulting number will be converted to the given
type T
, which must be able to losslessly store the parsed
value; this is enforced by the constraint on the type. This
accounts for unsignedness when necessary.
Attributes
- T
the desired type of the result, defaulting to
Byte
- 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.- Source:
- Integer.scala
This parser will behave the same as octal
except it will ensure that the resulting BigInt
is a valid 16-bit
number.
This parser will behave the same as octal
except it will ensure that the resulting BigInt
is a valid 16-bit
number. The resulting number will be converted to the given
type T
, which must be able to losslessly store the parsed
value; this is enforced by the constraint on the type. This
accounts for unsignedness when necessary.
Attributes
- T
the desired type of the result, defaulting to
Short
- 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.- Source:
- Integer.scala
This parser will behave the same as octal
except it will ensure that the resulting BigInt
is a valid 32-bit
number.
This parser will behave the same as octal
except it will ensure that the resulting BigInt
is a valid 32-bit
number. The resulting number will be converted to the given
type T
, which must be able to losslessly store the parsed
value; this is enforced by the constraint on the type. This
accounts for unsignedness when necessary.
Attributes
- T
the desired type of the result, defaulting to
Int
- 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.- Source:
- Integer.scala
This parser will behave the same as octal
except it will ensure that the resulting BigInt
is a valid 64-bit
number.
This parser will behave the same as octal
except it will ensure that the resulting BigInt
is a valid 64-bit
number. The resulting number will be converted to the given
type T
, which must be able to losslessly store the parsed
value; this is enforced by the constraint on the type. This
accounts for unsignedness when necessary.
Attributes
- T
the desired type of the result, defaulting to
Long
- 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.- Source:
- Integer.scala
This parser will behave the same as octal
except it will ensure that the resulting BigInt
is a valid 8-bit
number.
This parser will behave the same as octal
except it will ensure that the resulting BigInt
is a valid 8-bit
number. The resulting number will be converted to the given
type T
, which must be able to losslessly store the parsed
value; this is enforced by the constraint on the type. This
accounts for unsignedness when necessary.
Attributes
- T
the desired type of the result, defaulting to
Byte
- 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.- Source:
- Integer.scala