abstract class Names extends AnyRef
This class defines a uniform interface for defining parsers for user-defined names (identifiers and operators), independent of how whitespace should be handled after the name.
- Source
- Names.scala
- Since
4.0.0
- Note
implementations of this class found within
Lexer
may employ sharing and refine thedef
s in this class intoval
orlazy val
when overriding.
- Alphabetic
- By Inheritance
- Names
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Abstract Value Members
- abstract def identifier(startChar: CharPredicate): Parsley[String]
This combinator will parse an identifier based on the provided identifier start and described identifier letter.
This combinator will parse an identifier based on the provided identifier start and described identifier letter. It is capable of handling unicode characters if the configuration permits.
After parsing a valid identifier as in
identifier
, this combinator will verify that the first character matches the given parameter. IfNotRequired
is passed, this combinator will be equivalent toidentifier
.If hard keywords are specified by the configuration, this parser is not permitted to parse them.
- startChar
describes what the starting character must be
// identifierStart = Basic(_.isLetter) // identifierLetter = Basic(_.isLetterOrDigit) // hardKeywords = Set("if", ...) scala> identifier(Basic(_.isLower)).parse("x1") val res0 = Success("x1") scala> identifier(Basic(_.isLower)).parse("X1") val res1 = Failure(...) scala> identifier(Basic(_.isLower)).parse("1x") val res2 = Failure(...) scala> identifier(Basic(_.isLower)).parse("") val res3 = Failure(...) scala> identifier(Basic(_.isLower)).parse("iffy") val res4 = Success("iffy") scala> identifier(Basic(_.isLower)).parse("if") val res5 = Failure(...)
- Since
4.0.0
- Note
the exact behaviour of this parser is decided by the implementations given in
Lexer
, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.
Example: - abstract def identifier: Parsley[String]
This parser will parse an identifier based on the defined identifier start and identifier letter.
This parser will parse an identifier based on the defined identifier start and identifier letter. It is capable of handling unicode characters if the configuration permits. If hard keywords are specified by the configuration, this parser is not permitted to parse them.
// identifierStart = Basic(_.isLetter) // identifierLetter = Basic(_.isLetterOrDigit) // hardKeywords = Set("if", ...) scala> identifier.parse("x1") val res0 = Success("x1") scala> identifier.parse("1x") val res1 = Failure(...) scala> identifier.parse("") val res2 = Failure(...) scala> identifier.parse("iffy") val res3 = Success("iffy") scala> identifier.parse("if") val res4 = Failure(...)
- Since
4.0.0
- Note
the exact behaviour of this parser is decided by the implementations given in
Lexer
, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.
Example: - abstract def userDefinedOperator(startChar: CharPredicate, endChar: CharPredicate): Parsley[String]
This combinator will parse a user-defined operator based on the defined operator start and operator letter, refined by the provided
startChar
andendChar
.This combinator will parse a user-defined operator based on the defined operator start and operator letter, refined by the provided
startChar
andendChar
. It is capable of handling unicode characters if the configuration permits.After parsing a valid operator as in
userDefinedOperator
, this combinator will verify that the first and last characters match the given parameters. IfNotRequired
is passed to either argument, this will permit any character. Passing it to both arguments will be equivalent touserDefinedOperator
.If hard operators are specified by the configuration, this parser is not permitted to parse them.
- startChar
describes what the starting character must be
- endChar
describes what the final character must be
// operatorStart = Basic(Set('+', '-')) // operatorLetter = Basic(Set('+', '-', ':')) // hardKeywords = Set("+", "+:", ...) scala> userDefinedOperator(NotRequired, Basic(Set(':'))).parse("-:") val res0 = Success("-:") scala> userDefinedOperator(NotRequired, Basic(Set(':'))).parse("*:") val res1 = Failure(...) scala> userDefinedOperator(NotRequired, Basic(Set(':'))).parse("") val res2 = Failure(...) scala> userDefinedOperator(NotRequired, Basic(Set(':'))).parse("++") val res3 = Failure(...) scala> userDefinedOperator(NotRequired, Basic(Set(':'))).parse("+:") val res4 = Failure(...) scala> userDefinedOperator(NotRequired, Basic(Set(':'))).parse("++:") val res5 = Success("++:")
- Since
4.0.0
- Note
the exact behaviour of this parser is decided by the implementations given in
Lexer
, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.
Example: - abstract def userDefinedOperator: Parsley[String]
This parser will parse a user-defined operator based on the defined operator start and operator letter.
This parser will parse a user-defined operator based on the defined operator start and operator letter. It is capable of handling unicode characters if the configuration permits. If hard operators are specified by the configuration, this parser is not permitted to parse them.
// operatorStart = Basic(Set('+', '-')) // operatorLetter = Basic(Set('+', '-', ':')) // hardKeywords = Set("+", "+:", ...) scala> userDefinedOperator.parse("-:") val res0 = Success("-:") scala> userDefinedOperator.parse("*:") val res1 = Failure(...) scala> userDefinedOperator.parse("") val res2 = Failure(...) scala> userDefinedOperator.parse("++") val res3 = Success("++") scala> userDefinedOperator.parse("+:") val res4 = Failure(...) scala> userDefinedOperator.parse("++:") val res5 = Success("++:")
- Since
4.0.0
- Note
the exact behaviour of this parser is decided by the implementations given in
Lexer
, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.
Example:
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
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- 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])
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- 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 synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- final def userDefinedOperator(startChar: CharPredicate): Parsley[String]
This combinator will parse a user-defined operator based on the defined operator start and operator letter, refined by the provided
startChar
.This combinator will parse a user-defined operator based on the defined operator start and operator letter, refined by the provided
startChar
. It is capable of handling unicode characters if the configuration permits.After parsing a valid operator as in
userDefinedOperator
, this combinator will verify that the first character matches the given parameter. IfNotRequired
is passed it will be equivalent touserDefinedOperator
.If hard operators are specified by the configuration, this parser is not permitted to parse them.
- startChar
describes what the starting character must be
// operatorStart = Basic(Set('+', '-')) // operatorLetter = Basic(Set('+', '-', ':')) // hardKeywords = Set("+", "+:", ...) scala> userDefinedOperator(Basic(Set('+'))).parse("-:") val res0 = Failure(...) scala> userDefinedOperator(Basic(Set('+'))).parse("*:") val res1 = Failure(...) scala> userDefinedOperator(Basic(Set('+'))).parse("") val res2 = Failure(...) scala> userDefinedOperator(Basic(Set('+'))).parse("++") val res3 = Success("++") scala> userDefinedOperator(Basic(Set('+'))).parse("+:") val res4 = Failure(...) scala> userDefinedOperator(Basic(Set('+'))).parse("++:") val res5 = Success("++:")
- Since
4.1.0
- Note
the exact behaviour of this parser is decided by the implementations given in
Lexer
, which will depend on user-defined configuration. Please see the relevant documentation of these specific objects.
Example: - 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()
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.