Combined

abstract class Combined extends AnyRef

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.

Source: Combined.scala
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.

Linear Supertypes

AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

Combined
AnyRef
Any

Hide All
Show All

Visibility

Public
Protected

Abstract Value Members

abstract 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 .
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.
See also
Integer.binary and Real.binary
abstract def bounded[T](number: Parsley[Either[BigInt, BigDecimal]], bits: Bits, radix: Int)(implicit ev: CanHold[self, T]): Parsley[Either[T, BigDecimal]]
Attributes
protected[numeric]
abstract 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 .
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.
See also
Integer.decimal and Real.decimal
abstract 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 .
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.
See also
Integer.hexadecimal and Real.hexadecimal
abstract 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.
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.
See also
Integer.number and Real.number
abstract 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 .
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.
See also
Integer.octal and Real.octal

Concrete Value Members

final def !=(arg0: Any): Boolean
Definition Classes
AnyRef → Any
final def ##: Int
Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean
Definition Classes
AnyRef → Any
def _binary: Parsley[Either[BigInt, BigDecimal]]
Attributes
protected[numeric]
def _decimal: Parsley[Either[BigInt, BigDecimal]]
Attributes
protected[numeric]
def _hexadecimal: Parsley[Either[BigInt, BigDecimal]]
Attributes
protected[numeric]
def _number: Parsley[Either[BigInt, BigDecimal]]
Attributes
protected[numeric]
def _octal: Parsley[Either[BigInt, BigDecimal]]
Attributes
protected[numeric]
final def asInstanceOf[T0]: T0
Definition Classes
Any
final def binary16[T](implicit arg0: can_hold_16_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.binary16 and Real.binary
final def binary16Double[T](implicit arg0: can_hold_16_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.binary16 and Real.binaryDouble
final def binary16Float[T](implicit arg0: can_hold_16_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.binary16 and Real.binaryFloat
final def binary32[T](implicit arg0: can_hold_32_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.binary32 and Real.binary
final def binary32Double[T](implicit arg0: can_hold_32_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.binary32 and Real.binaryDouble
final def binary32Float[T](implicit arg0: can_hold_32_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.binary32 and Real.binaryFloat
final def binary64[T](implicit arg0: can_hold_64_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.binary64 and Real.binary
final def binary64Double[T](implicit arg0: can_hold_64_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.binary64 and Real.binaryDouble
final def binary64Float[T](implicit arg0: can_hold_64_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.binary64 and Real.binaryFloat
final def binary8[T](implicit arg0: can_hold_8_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.binary8 and Real.binary
final def binary8Double[T](implicit arg0: can_hold_8_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.binary8 and Real.binaryDouble
final def binary8Float[T](implicit arg0: can_hold_8_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.binary8 and Real.binaryFloat
def clone(): AnyRef
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.CloneNotSupportedException]) @native()
final def decimal16[T](implicit arg0: can_hold_16_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.decimal16 and Real.decimal
final def decimal16Double[T](implicit arg0: can_hold_16_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.decimal16 and Real.decimalDouble
final def decimal16Float[T](implicit arg0: can_hold_16_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.decimal16 and Real.decimalFloat
final def decimal32[T](implicit arg0: can_hold_32_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.decimal32 and Real.decimal
final def decimal32Double[T](implicit arg0: can_hold_32_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.decimal32 and Real.decimalDouble
final def decimal32Float[T](implicit arg0: can_hold_32_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.decimal32 and Real.decimalFloat
final def decimal64[T](implicit arg0: can_hold_64_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.decimal64 and Real.decimal
final def decimal64Double[T](implicit arg0: can_hold_64_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.decimal64 and Real.decimalDouble
final def decimal64Float[T](implicit arg0: can_hold_64_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.decimal64 and Real.decimalFloat
final def decimal8[T](implicit arg0: can_hold_8_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.decimal8 and Real.decimal
final def decimal8Double[T](implicit arg0: can_hold_8_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.decimal8 and Real.decimalDouble
final def decimal8Float[T](implicit arg0: can_hold_8_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.decimal8 and Real.decimalFloat
def ensureDouble[T](number: Parsley[Either[T, BigDecimal]]): Parsley[Either[T, Double]]
Attributes
protected[numeric]
def ensureFloat[T](number: Parsley[Either[T, BigDecimal]]): Parsley[Either[T, Float]]
Attributes
protected[numeric]
final def eq(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def equals(arg0: AnyRef): Boolean
Definition Classes
AnyRef → Any
def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.Throwable])
final def getClass(): Class[_ <: AnyRef]
Definition Classes
AnyRef → Any
Annotations
@native()
def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native()
final def hexadecimal16[T](implicit arg0: can_hold_16_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.hexadecimal16 and Real.hexadecimal
final def hexadecimal16Double[T](implicit arg0: can_hold_16_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.hexadecimal16 and Real.hexadecimalDouble
final def hexadecimal16Float[T](implicit arg0: can_hold_16_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.hexadecimal16 and Real.hexadecimalFloat
final def hexadecimal32[T](implicit arg0: can_hold_32_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.hexadecimal32 and Real.hexadecimal
final def hexadecimal32Double[T](implicit arg0: can_hold_32_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.hexadecimal32 and Real.hexadecimalDouble
final def hexadecimal32Float[T](implicit arg0: can_hold_32_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.hexadecimal32 and Real.hexadecimalFloat
final def hexadecimal64[T](implicit arg0: can_hold_64_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.hexadecimal64 and Real.hexadecimal
final def hexadecimal64Double[T](implicit arg0: can_hold_64_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.hexadecimal64 and Real.hexadecimalDouble
final def hexadecimal64Float[T](implicit arg0: can_hold_64_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.hexadecimal64 and Real.hexadecimalFloat
final def hexadecimal8[T](implicit arg0: can_hold_8_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.hexadecimal8 and Real.hexadecimal
final def hexadecimal8Double[T](implicit arg0: can_hold_8_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.hexadecimal8 and Real.hexadecimalDouble
final def hexadecimal8Float[T](implicit arg0: can_hold_8_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.hexadecimal8 and Real.hexadecimalFloat
final def isInstanceOf[T0]: Boolean
Definition Classes
Any
final def ne(arg0: AnyRef): Boolean
Definition Classes
AnyRef
final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
final def number16[T](implicit arg0: can_hold_16_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.number8 and Real.number
final def number16Double[T](implicit arg0: can_hold_16_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.number16 and Real.double
final def number16Float[T](implicit arg0: can_hold_16_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.number16 and Real.float
final def number32[T](implicit arg0: can_hold_32_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.number32 and Real.number
final def number32Double[T](implicit arg0: can_hold_32_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.number32 and Real.double
final def number32Float[T](implicit arg0: can_hold_32_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.number32 and Real.float
final def number64[T](implicit arg0: can_hold_64_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.number8 and Real.number
final def number64Double[T](implicit arg0: can_hold_64_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.number64 and Real.double
final def number64Float[T](implicit arg0: can_hold_64_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.number64 and Real.float
final def number8[T](implicit arg0: can_hold_8_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.number8 and Real.number
final def number8Double[T](implicit arg0: can_hold_8_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.number8 and Real.double
final def number8Float[T](implicit arg0: can_hold_8_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.number8 and Real.float
final def octal16[T](implicit arg0: can_hold_16_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.octal16 and Real.octal
final def octal16Double[T](implicit arg0: can_hold_16_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.octal16 and Real.octalDouble
final def octal16Float[T](implicit arg0: can_hold_16_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.octal16 and Real.octalFloat
final def octal32[T](implicit arg0: can_hold_32_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.octal32 and Real.octal
final def octal32Double[T](implicit arg0: can_hold_32_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.octal32 and Real.octalDouble
final def octal32Float[T](implicit arg0: can_hold_32_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.octal32 and Real.octalFloat
final def octal64[T](implicit arg0: can_hold_64_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.octal64 and Real.octal
final def octal64Double[T](implicit arg0: can_hold_64_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.octal64 and Real.octalDouble
final def octal64Float[T](implicit arg0: can_hold_64_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.octal64 and Real.octalFloat
final def octal8[T](implicit arg0: can_hold_8_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.octal8 and Real.octal
final def octal8Double[T](implicit arg0: can_hold_8_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.octal8 and Real.octalDouble
final def octal8Float[T](implicit arg0: can_hold_8_bits[T]): 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).
Annotations
@inline()
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.
See also
Integer.octal8 and Real.octalFloat
final def synchronized[T0](arg0: => T0): T0
Definition Classes
AnyRef
def toString(): String
Definition Classes
AnyRef → Any
final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException]) @native()

Packages

Combined

abstract class Combined extends AnyRef

Abstract Value Members

Concrete Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

Combined

abstract class Combined extends AnyRef

Abstract Value Members

Concrete Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Combined