parsley
API
Generated with
© 2002-2021 · LAMP/EPFL
© 2002-2021 · LAMP/EPFL
parsley/parsley.token.numeric/Combined

Combined

parsley.token.numeric.Combined
abstract class Combined

This class defines a uniform interface for defining parsers for mixed kind numeric 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.

Graph
Supertypes
class Object
trait Matchable
class Any

Members list

Concise view

Value members

Abstract methods

def binary: Parsley[Either[BigInt, BigDecimal]]

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes .

Attributes

See also:
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.

def decimal: Parsley[Either[BigInt, BigDecimal]]

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes .

Attributes

See also:
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.

def hexadecimal: Parsley[Either[BigInt, BigDecimal]]

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes .

Attributes

See also:
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.

def number: Parsley[Either[BigInt, BigDecimal]]

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes . Depending on the configuration this may be able to handle different bases for each type of number.

Attributes

See also:
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.

def octal: Parsley[Either[BigInt, BigDecimal]]

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes .

Attributes

See also:
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.

Concrete methods

final def binary16[T : can_hold_16_bits]: Parsley[Either[T, BigDecimal]]

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def binary16Double[T : can_hold_16_bits]: Parsley[Either[T, Double]]

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def binary16Float[T : can_hold_16_bits]: Parsley[Either[T, Float]]

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def binary32[T : can_hold_32_bits]: Parsley[Either[T, BigDecimal]]

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def binary32Double[T : can_hold_32_bits]: Parsley[Either[T, Double]]

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def binary32Float[T : can_hold_32_bits]: Parsley[Either[T, Float]]

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def binary64[T : can_hold_64_bits]: Parsley[Either[T, BigDecimal]]

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def binary64Double[T : can_hold_64_bits]: Parsley[Either[T, Double]]

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def binary64Float[T : can_hold_64_bits]: Parsley[Either[T, Float]]

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def binary8[T : can_hold_8_bits]: Parsley[Either[T, BigDecimal]]

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def binary8Double[T : can_hold_8_bits]: Parsley[Either[T, Double]]

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def binary8Float[T : can_hold_8_bits]: Parsley[Either[T, Float]]

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real binary number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def decimal16[T : can_hold_16_bits]: Parsley[Either[T, BigDecimal]]

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def decimal16Double[T : can_hold_16_bits]: Parsley[Either[T, Double]]

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def decimal16Float[T : can_hold_16_bits]: Parsley[Either[T, Float]]

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def decimal32[T : can_hold_32_bits]: Parsley[Either[T, BigDecimal]]

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def decimal32Double[T : can_hold_32_bits]: Parsley[Either[T, Double]]

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def decimal32Float[T : can_hold_32_bits]: Parsley[Either[T, Float]]

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def decimal64[T : can_hold_64_bits]: Parsley[Either[T, BigDecimal]]

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def decimal64Double[T : can_hold_64_bits]: Parsley[Either[T, Double]]

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def decimal64Float[T : can_hold_64_bits]: Parsley[Either[T, Float]]

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def decimal8[T : can_hold_8_bits]: Parsley[Either[T, BigDecimal]]

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def decimal8Double[T : can_hold_8_bits]: Parsley[Either[T, Double]]

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def decimal8Float[T : can_hold_8_bits]: Parsley[Either[T, Float]]

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real decimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def hexadecimal16[T : can_hold_16_bits]: Parsley[Either[T, BigDecimal]]

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def hexadecimal16Double[T : can_hold_16_bits]: Parsley[Either[T, Double]]

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def hexadecimal16Float[T : can_hold_16_bits]: Parsley[Either[T, Float]]

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def hexadecimal32[T : can_hold_32_bits]: Parsley[Either[T, BigDecimal]]

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def hexadecimal32Double[T : can_hold_32_bits]: Parsley[Either[T, Double]]

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def hexadecimal32Float[T : can_hold_32_bits]: Parsley[Either[T, Float]]

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def hexadecimal64[T : can_hold_64_bits]: Parsley[Either[T, BigDecimal]]

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def hexadecimal64Double[T : can_hold_64_bits]: Parsley[Either[T, Double]]

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def hexadecimal64Float[T : can_hold_64_bits]: Parsley[Either[T, Float]]

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def hexadecimal8[T : can_hold_8_bits]: Parsley[Either[T, BigDecimal]]

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def hexadecimal8Double[T : can_hold_8_bits]: Parsley[Either[T, Double]]

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def hexadecimal8Float[T : can_hold_8_bits]: Parsley[Either[T, Float]]

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real hexadecimal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def number16[T : can_hold_16_bits]: Parsley[Either[T, BigDecimal]]

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def number16Double[T : can_hold_16_bits]: Parsley[Either[T, Double]]

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def number16Float[T : can_hold_16_bits]: Parsley[Either[T, Float]]

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def number32[T : can_hold_32_bits]: Parsley[Either[T, BigDecimal]]

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def number32Double[T : can_hold_32_bits]: Parsley[Either[T, Double]]

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def number32Float[T : can_hold_32_bits]: Parsley[Either[T, Float]]

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def number64[T : can_hold_64_bits]: Parsley[Either[T, BigDecimal]]

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def number64Double[T : can_hold_64_bits]: Parsley[Either[T, Double]]

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def number64Float[T : can_hold_64_bits]: Parsley[Either[T, Float]]

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def number8[T : can_hold_8_bits]: Parsley[Either[T, BigDecimal]]

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def number8Double[T : can_hold_8_bits]: Parsley[Either[T, Double]]

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def number8Float[T : can_hold_8_bits]: Parsley[Either[T, Float]]

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def octal16[T : can_hold_16_bits]: Parsley[Either[T, BigDecimal]]

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def octal16Double[T : can_hold_16_bits]: Parsley[Either[T, Double]]

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def octal16Float[T : can_hold_16_bits]: Parsley[Either[T, Float]]

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def octal32[T : can_hold_32_bits]: Parsley[Either[T, BigDecimal]]

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def octal32Double[T : can_hold_32_bits]: Parsley[Either[T, Double]]

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def octal32Float[T : can_hold_32_bits]: Parsley[Either[T, Float]]

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def octal64[T : can_hold_64_bits]: Parsley[Either[T, BigDecimal]]

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def octal64Double[T : can_hold_64_bits]: Parsley[Either[T, Double]]

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def octal64Float[T : can_hold_64_bits]: Parsley[Either[T, Float]]

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def octal8[T : can_hold_8_bits]: Parsley[Either[T, BigDecimal]]

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def octal8Double[T : can_hold_8_bits]: Parsley[Either[T, Double]]

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

final def octal8Float[T : can_hold_8_bits]: Parsley[Either[T, Float]]

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes .

This parser will parse either an integer or a real octal number, handling any ambiguity with the prefixes . Additionally, the type is further constrained (see the corresponding parsers).

Attributes

See also:
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.

Generated with
© 2002-2021 · LAMP/EPFL
© 2002-2021 · LAMP/EPFL