Integer

parsley.token.numeric.Integer

abstract class 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-final defs in this class into val or lazy val when overriding.
Source:: Integer.scala
Graph
Supertypes: class Object
trait Matchable
class Any

Members list

Concise view

Value members

Abstract methods

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).

Attributes

Since:

4.0.0

Note:

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).

Attributes

Since:

4.0.0

Note:

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.

Attributes

Since:

4.0.0

Note:

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).

Attributes

Since:

4.0.0

Note:

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

Generated with