parsley
5.0.0-M2
API
Generated with
parsley/parsley/parsley.token/parsley.token.numeric/IntegerParsers

IntegerParsers

parsley.token.numeric.IntegerParsers
abstract class IntegerParsers

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

Value members

Abstract methods

def binary: Parsley[BigInt]

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
def decimal: Parsley[BigInt]

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
def hexadecimal: Parsley[BigInt]

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
def number: Parsley[BigInt]

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
def octal: Parsley[BigInt]

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

final def binary16[T : can_hold_16_bits]: Parsley[T]

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.

Type parameters

T

the desired type of the result, defaulting to Short

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.

Source
Integer.scala
final def binary32[T : can_hold_32_bits]: Parsley[T]

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.

Type parameters

T

the desired type of the result, defaulting to Int

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.

Source
Integer.scala
final def binary64[T : can_hold_64_bits]: Parsley[T]

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.

Type parameters

T

the desired type of the result, defaulting to Long

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.

Source
Integer.scala
final def binary8[T : can_hold_8_bits]: Parsley[T]

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.

Type parameters

T

the desired type of the result, defaulting to Byte

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.

Source
Integer.scala
final def decimal16[T : can_hold_16_bits]: Parsley[T]

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.

Type parameters

T

the desired type of the result, defaulting to Short

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.

Source
Integer.scala
final def decimal32[T : can_hold_32_bits]: Parsley[T]

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.

Type parameters

T

the desired type of the result, defaulting to Int

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.

Source
Integer.scala
final def decimal64[T : can_hold_64_bits]: Parsley[T]

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.

Type parameters

T

the desired type of the result, defaulting to Long

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.

Source
Integer.scala
final def decimal8[T : can_hold_8_bits]: Parsley[T]

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.

Type parameters

T

the desired type of the result, defaulting to Byte

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.

Source
Integer.scala
final def hexadecimal16[T : can_hold_16_bits]: Parsley[T]

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.

Type parameters

T

the desired type of the result, defaulting to Short

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.

Source
Integer.scala
final def hexadecimal32[T : can_hold_32_bits]: Parsley[T]

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.

Type parameters

T

the desired type of the result, defaulting to Int

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.

Source
Integer.scala
final def hexadecimal64[T : can_hold_64_bits]: Parsley[T]

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.

Type parameters

T

the desired type of the result, defaulting to Long

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.

Source
Integer.scala
final def hexadecimal8[T : can_hold_8_bits]: Parsley[T]

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.

Type parameters

T

the desired type of the result, defaulting to Byte

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.

Source
Integer.scala
final def number16[T : can_hold_16_bits]: Parsley[T]

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.

Type parameters

T

the desired type of the result, defaulting to Short

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.

Source
Integer.scala
final def number32[T : can_hold_32_bits]: Parsley[T]

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.

Type parameters

T

the desired type of the result, defaulting to Int

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.

Source
Integer.scala
final def number64[T : can_hold_64_bits]: Parsley[T]

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.

Type parameters

T

the desired type of the result, defaulting to Long

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.

Source
Integer.scala
final def number8[T : can_hold_8_bits]: Parsley[T]

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.

Type parameters

T

the desired type of the result, defaulting to Byte

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.

Source
Integer.scala
final def octal16[T : can_hold_16_bits]: Parsley[T]

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.

Type parameters

T

the desired type of the result, defaulting to Short

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.

Source
Integer.scala
final def octal32[T : can_hold_32_bits]: Parsley[T]

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.

Type parameters

T

the desired type of the result, defaulting to Int

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.

Source
Integer.scala
final def octal64[T : can_hold_64_bits]: Parsley[T]

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.

Type parameters

T

the desired type of the result, defaulting to Long

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.

Source
Integer.scala
final def octal8[T : can_hold_8_bits]: Parsley[T]

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.

Type parameters

T

the desired type of the result, defaulting to Byte

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.

Source
Integer.scala
Generated with