object nonlexeme
This object is concerned with non-lexemes: these are tokens that do not give any special treatment to whitespace.
Whilst the functionality in lexeme
is strongly recommended for
wider use in a parser, the functionality here may be useful for more
specialised use-cases. In particular, these may for the building blocks
for more complex tokens (where whitespace is not allowed between them, say),
in which case these compound tokens can be turned into lexemes manually.
For example, the lexer does not have configuration for trailing specifiers
on numeric literals (like, 1024L
in Scala, say): the desired numeric
literal parser could be extended with this functionality before whitespace
is consumed by using the variant found in this object.
Alternatively, these tokens can be used for lexical extraction, which
can be performed by the ErrorBuilder
typeclass: this can be used to try and extract tokens from the input stream
when an error happens, to provide a more informative error. In this case,
it is desirable to not consume whitespace after the token to keep the
error tight and precise.
- Source
- Lexer.scala
- Since
4.0.0
- Alphabetic
- By Inheritance
- nonlexeme
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
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
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def character: Character
This is a collection of parsers concerned with handling character literals.
This is a collection of parsers concerned with handling character literals.
Character literals are described generally as follows:
desc.textDesc.characterLiteralEnd
: the character that starts and ends the literal (for example in many languages this is'
)desc.textDesc.graphicCharacter
: describes the legal characters that may appear in the literal directly. Usually, this excludes control characters and newlines, but permits most other things. Escape sequences can represent non-graphic charactersdesc.textDesc.escapeSequences
: describes the legal escape sequences that that can appear in a character literal (for example\n
or\u000a
)
Aside from the generic configuration, characters can be parsed in accordance with varying levels of unicode support, from ASCII-only to full UTF-16 characters. Parsers for each of four different vareties are exposed by this object.
- Since
4.5.0
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- 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])
- def floating: Real
This is a collection of parsers concerned with handling signed real numbers (like floats and doubles).
This is a collection of parsers concerned with handling signed real numbers (like floats and doubles).
These literals consist of a (possibly optional) integer prefix, with at least one of a fractional component (with
.
) or an exponential component.Real numbers are an extension of signed integers with the following additional configuration:
desc.numericDesc.leadingDotAllowed
: determines whether a literal like.0
would be considered legaldesc.numericDesc.trailingDotAllowed
: determines whether a literal like0.
would be considered legaldesc.numericDesc.realNumbersCanBe{Hexadecimal/Octal/Binary}
: these flags control what kind of literals can appear within thenumber
parser. Each type of literal may still be individually parsed with its corresponding parser, regardless of the value of the flagdesc.numericDesc.{decimal/hexadecimal/octal/binary}ExponentDesc
: describes how the exponential syntax works for each kind of base. If the syntax is legal, then this describes: which characters start it (classically, this would bee
orE
for decimals); whether or not it is compulsory for the literal (in Java and C, hexadecimal floats are only valid when they have an exponent attached); and whether or not a+
sign is mandatory, optional, or illegal for positive exponents
Additional to the parsing of decimal, hexadecimal, octal, and binary floating literals, each parser can be given a precision of IEEE 754 float or double. This can either be achieved by rounding to the nearest representable value, or by ensuring that the literal must be precisely representable as one of these numbers (which is defined as being one of binary, decimal or exact
float
anddouble
values as described by Java) - final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def integer: Integer
This is a collection of parsers concerned with handling signed integer literals.
This is a collection of parsers concerned with handling signed integer literals.
Signed integer literals are an extension of unsigned integer literals with the following extra configuration:
desc.numericDesc.positiveSign
: describes whether or not literals are allowed to omit+
for positive literals, must write a+
, or can never write a+
.
- Since
4.5.0
- See also
natural
for a full description of integer configuration
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def multiString: String
This is a collection of parsers concerned with handling multi-line string literals.
This is a collection of parsers concerned with handling multi-line string literals.
String literals are described generally as follows:
desc.textDesc.multiStringEnds
: the sequence of characters that can begin or end a multi-line string literal. Regardless of which of these is used for a specific literal, the end of the literal must use the same sequencedesc.textDesc.graphicCharacter
: describes the legal characters that may appear in the literal directly. Usually, this excludes control characters and newlines, but permits most other things. Escape sequences can represent non-graphic characters for non-raw stringsdesc.textDesc.escapeSequences
: describes the legal escape sequences that that can appear in a string literal (for example\n
or\u000a
)
- Since
4.5.0
- val names: Names
This object contains lexing functionality relevant to the parsing of names, which include operators or identifiers.
This object contains lexing functionality relevant to the parsing of names, which include operators or identifiers.
The parsing of names is mostly concerned with finding the longest valid name that is not a reserved name, such as a hard keyword or a special operator.
- Since
4.0.0
- def natural: Integer
This is a collection of parsers concerned with handling unsigned (positive) integer literals.
This is a collection of parsers concerned with handling unsigned (positive) integer literals.
Natural numbers are described generally as follows:
desc.numericDesc.literalBreakChar
: determines whether or not it is legal to "break up" the digits within a literal, for example: is1_000_000
allowed? If this is legal, describes what the break character is, and whether it can appear after a hexadecimal/octal/binary prefixdesc.numericDesc.leadingZerosAllowed
: determines whether or not it is possible to add extraneous zero digits onto the front of a number or not. In some languages, like C, this is disallowed, as numbers starting with0
are octal numbers.desc.numericDesc.integerNumbersCanBe{Hexadecimal/Octal/Binary}
: these flags control what kind of literals can appear within thenumber
parser. Each type of literal can be individually parsed with its corresponding parser, regardless of the value of the flagdesc.numericDesc.{hexadecimal/octal/binary}Leads
: controls what character must follow a0
when starting a number to change it from decimal into another base. This set may be empty, in which case the literal is described purely with leading zero (C style octals would setoctalLeads
toSet.empty
)
Additional to the parsing of decimal, hexadecimal, octal, and binary literals, each parser can be given a bit-width from 8- to 64-bit: this will check the parsed literal to ensure it is a legal literal of that size.
- Since
4.5.0
- 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()
- def rawMultiString: String
This is a collection of parsers concerned with handling multi-line string literals.
This is a collection of parsers concerned with handling multi-line string literals.
String literals are described generally as follows:
desc.textDesc.multiStringEnds
: the sequence of characters that can begin or end a multi-line string literal. Regardless of which of these is used for a specific literal, the end of the literal must use the same sequencedesc.textDesc.graphicCharacter
: describes the legal characters that may appear in the literal directly. Usually, this excludes control characters and newlines, but permits most other things. Escape sequences can represent non-graphic characters for non-raw stringsdesc.textDesc.escapeSequences
: describes the legal escape sequences that that can appear in a string literal (for example\n
or\u000a
)
- Since
4.5.0
- Note
this will be parsed without handling any escape sequences, this includes literal-end characters and the escape prefix (often
"
and\
respectively)
- def rawString: String
This is a collection of parsers concerned with handling single-line string literals.
This is a collection of parsers concerned with handling single-line string literals.
String literals are described generally as follows:
desc.textDesc.stringEnds
: the sequence of characters that can begin or end a string literal. Regardless of which of these is used for a specific literal, the end of the literal must use the same sequencedesc.textDesc.graphicCharacter
: describes the legal characters that may appear in the literal directly. Usually, this excludes control characters and newlines, but permits most other things. Escape sequences can represent non-graphic characters for non-raw stringsdesc.textDesc.escapeSequences
: describes the legal escape sequences that that can appear in a string literal (for example\n
or\u000a
)
- Since
4.5.0
- Note
this will be parsed without handling any escape sequences, this includes literal-end characters and the escape prefix (often
"
and\
respectively)
- def real: Real
This is a collection of parsers concerned with handling signed real numbers (like floats and doubles).
This is a collection of parsers concerned with handling signed real numbers (like floats and doubles).
These literals consist of a (possibly optional) integer prefix, with at least one of a fractional component (with
.
) or an exponential component.Real numbers are an extension of signed integers with the following additional configuration:
desc.numericDesc.leadingDotAllowed
: determines whether a literal like.0
would be considered legaldesc.numericDesc.trailingDotAllowed
: determines whether a literal like0.
would be considered legaldesc.numericDesc.realNumbersCanBe{Hexadecimal/Octal/Binary}
: these flags control what kind of literals can appear within thenumber
parser. Each type of literal may still be individually parsed with its corresponding parser, regardless of the value of the flagdesc.numericDesc.{decimal/hexadecimal/octal/binary}ExponentDesc
: describes how the exponential syntax works for each kind of base. If the syntax is legal, then this describes: which characters start it (classically, this would bee
orE
for decimals); whether or not it is compulsory for the literal (in Java and C, hexadecimal floats are only valid when they have an exponent attached); and whether or not a+
sign is mandatory, optional, or illegal for positive exponents
Additional to the parsing of decimal, hexadecimal, octal, and binary floating literals, each parser can be given a precision of IEEE 754 float or double. This can either be achieved by rounding to the nearest representable value, or by ensuring that the literal must be precisely representable as one of these numbers (which is defined as being one of binary, decimal or exact
float
anddouble
values as described by Java) - def signed: Integer
This is a collection of parsers concerned with handling signed integer literals.
This is a collection of parsers concerned with handling signed integer literals.
Signed integer literals are an extension of unsigned integer literals with the following extra configuration:
desc.numericDesc.positiveSign
: describes whether or not literals are allowed to omit+
for positive literals, must write a+
, or can never write a+
.
- def signedCombined: Combined
This is a collection of parsers concerned with handling numeric literals that may either be signed integers or signed reals.
This is a collection of parsers concerned with handling numeric literals that may either be signed integers or signed reals.
There is no additional configuration offered over that found in
integer
orreal
.the bit-bounds and precision of the integer or real parts of the result can be specified in any pairing.
- Since
4.5.0
- def string: String
This is a collection of parsers concerned with handling single-line string literals.
This is a collection of parsers concerned with handling single-line string literals.
String literals are described generally as follows:
desc.textDesc.stringEnds
: the sequence of characters that can begin or end a string literal. Regardless of which of these is used for a specific literal, the end of the literal must use the same sequencedesc.textDesc.graphicCharacter
: describes the legal characters that may appear in the literal directly. Usually, this excludes control characters and newlines, but permits most other things. Escape sequences can represent non-graphic characters for non-raw stringsdesc.textDesc.escapeSequences
: describes the legal escape sequences that that can appear in a string literal (for example\n
or\u000a
)
- Since
4.5.0
- val symbol: Symbol
This object contains lexing functionality relevant to the parsing of atomic symbols.
This object contains lexing functionality relevant to the parsing of atomic symbols.
Symbols are characterised by their "unitness", that is, every parser inside returns
Unit
. This is because they all parse a specific known entity, and, as such, the result of the parse is irrelevant. These can be things such as reserved names, or small symbols like parentheses. This object also contains a means of creating new symbols as well as implicit conversions to allow for Scala's string literals to serve as symbols within a parser.- Since
4.0.0
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- def unsigned: Integer
This is a collection of parsers concerned with handling unsigned (positive) integer literals.
This is a collection of parsers concerned with handling unsigned (positive) integer literals.
Natural numbers are described generally as follows:
desc.numericDesc.literalBreakChar
: determines whether or not it is legal to "break up" the digits within a literal, for example: is1_000_000
allowed? If this is legal, describes what the break character is, and whether it can appear after a hexadecimal/octal/binary prefixdesc.numericDesc.leadingZerosAllowed
: determines whether or not it is possible to add extraneous zero digits onto the front of a number or not. In some languages, like C, this is disallowed, as numbers starting with0
are octal numbers.desc.numericDesc.integerNumbersCanBe{Hexadecimal/Octal/Binary}
: these flags control what kind of literals can appear within thenumber
parser. Each type of literal can be individually parsed with its corresponding parser, regardless of the value of the flagdesc.numericDesc.{hexadecimal/octal/binary}Leads
: controls what character must follow a0
when starting a number to change it from decimal into another base. This set may be empty, in which case the literal is described purely with leading zero (C style octals would setoctalLeads
toSet.empty
)
Additional to the parsing of decimal, hexadecimal, octal, and binary literals, each parser can be given a bit-width from 8- to 64-bit: this will check the parsed literal to ensure it is a legal literal of that size.
- Since
4.5.0
- Note
alias for
natural
.
- def unsignedCombined: Combined
This is a collection of parsers concerned with handling numeric literals that may either be unsigned integers or unsigned reals.
This is a collection of parsers concerned with handling numeric literals that may either be unsigned integers or unsigned reals.
There is no additional configuration offered over that found in
natural
orreal
.the bit-bounds and precision of the integer or real parts of the result can be specified in any pairing.
- Since
4.5.0
- 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()
Deprecated Value Members
- object numeric
This object contains lexing functionality relevant to the parsing of numbers.
This object contains lexing functionality relevant to the parsing of numbers. This is sub-divided into different categories:
- integers (both signed and unsigned)
- reals (signed only)
- a combination of the two (signed and unsigned)
These contain relevant functionality for the processing of decimal, hexadecimal, octal, and binary literals; or some mixed combination thereof (as specified by
desc.numericDesc
). Additionally, it is possible to ensure literals represent known sizes or precisions.- Annotations
- @deprecated
- Deprecated
(Since version 4.5.0) This will be removed in Parsley 5.0, the contents have been flattened
- Since
4.0.0
- object text
This object contains lexing functionality relevant to the parsing of text.
This object contains lexing functionality relevant to the parsing of text. This is sub-divided into different categories:
- string literals (both with escapes and raw)
- multi-line string literals (both with escapes and raw)
- character literals
These contain the relevant functionality required to specify the degree of unicode support for the underlying language, from ASCII to full UTF-16.
- Annotations
- @deprecated
- Deprecated
(Since version 4.5.0) This will be removed in Parsley 5.0, the contents have been flattened
- Since
4.0.0
This is the documentation for Parsley.
Package structure
The parsley package contains the
Parsley
class, as well as theResult
,Success
, andFailure
types. In addition to these, it also contains the following packages and "modules" (a module is defined as being an object which mocks a package):parsley.Parsley
contains the bulk of the core "function-style" combinators.parsley.combinator
contains many helpful combinators that simplify some common parser patterns.parsley.character
contains the combinators needed to read characters and strings, as well as combinators to match specific sub-sets of characters.parsley.debug
contains debugging combinators, helpful for identifying faults in parsers.parsley.expr
contains the following sub modules:parsley.expr.chain
contains combinators used in expression parsingparsley.expr.precedence
is a builder for expression parsers built on a precedence table.parsley.expr.infix
contains combinators used in expression parsing, but with more permissive types than their equivalents inchain
.parsley.expr.mixed
contains combinators that can be used for expression parsing, but where different fixities may be mixed on the same level: this is rare in practice.parsley.syntax
contains several implicits to add syntactic sugar to the combinators. These are sub-categorised into the following sub modules:parsley.syntax.character
contains implicits to allow you to use character and string literals as parsers.parsley.syntax.lift
enables postfix application of the lift combinator onto a function (or value).parsley.syntax.zipped
enables boths a reversed form of lift where the function appears on the right and is applied on a tuple (useful when type inference has failed) as well as a.zipped
method for building tuples out of several combinators.parsley.syntax.extension
contains syntactic sugar combinators exposed as implicit classes.parsley.errors
contains modules to deal with error messages, their refinement and generation.parsley.errors.combinator
provides combinators that can be used to either produce more detailed errors as well as refine existing errors.parsley.errors.tokenextractors
provides mixins for common token extraction strategies during error message generation: these can be used to avoid implementingunexpectedToken
in theErrorBuilder
.parsley.lift
contains functions which lift functions that work on regular types to those which now combine the results of parsers returning those same types. these are ubiquitous.parsley.ap
contains functions which allow for the application of a parser returning a function to several parsers returning each of the argument types.parsley.registers
contains combinators that interact with the context-sensitive functionality in the form of registers.parsley.token
contains theLexer
class that provides a host of helpful lexing combinators when provided with the description of a language.parsley.position
contains parsers for extracting position information.parsley.generic
contains some basic implementations of the Parser Bridge pattern (see Design Patterns for Parser Combinators in Scala, or the parsley wiki): these can be used before more specialised generic bridge traits can be constructed.