class VanillaGen[-A] extends ErrorGen[A]
An error generator for Vanilla errors, which can tune the unexpected message and a generated reason.
- Source
- ErrorGen.scala
- Since
4.4.0
- Alphabetic
- By Inheritance
- VanillaGen
- ErrorGen
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new VanillaGen()
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 adjustWidth(x: A, width: Int): Int
This method can be overridden to control how wide an error is based on the value and width that produces it.
This method can be overridden to control how wide an error is based on the value and width that produces it.
The width provides to this error generator likely comes directly from the span of the parser used to produce the required result. However, this may not be entirely accurate for how the user might want the error to be sized (perhaps there was whitespace, or the parser consumed more input than was necessary to pin-point the problem). In these cases, this method allows for custom logic to derive the actual width of the error message. By default, just returns the given
width
.- Definition Classes
- ErrorGen
- Since
4.4.0
- final def apply(p: Parsley[(A, Int)]): Parsley[Nothing]
This combinator takes a given parser and raises an error based on its returned results.
This combinator takes a given parser and raises an error based on its returned results.
The given parser produces a value and a width, which are used to synthesise and raise an error message derived from the value with the given width. This is a safe way of using
parser
, since it ensures that the result of the given parserp
is not optimised out.errGen(p)
is similar towithWidth(p).flatMap { case (x, w) => failCombinator(...) }
, in that it generates errors in a context-sensitive way. However, this is much more efficient than using the expensiveflatMap
, so it is provided as a primitive operation.- Definition Classes
- ErrorGen
- Since
4.4.0
- 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 parser: Parsley[((A, Int)) => Nothing]
This parser can be applied (postfix) to a parser returning a value and a width to generate an error message tailored to them.
This parser can be applied (postfix) to a parser returning a value and a width to generate an error message tailored to them.
This is not a generally safe operation to be performing, and should only be used within a combinator that is guaranteed to use its results. The optimiser is not aware that the results of the parser this will be applied to will actually be needed, and so may optimise them out. Using this parser inside an arm of
select
orbranch
, say, would be safe, because these combinators force the result of their condition to be generated, butp <**> this.parser
is not generally safe without a use ofimpure
to guard it. This is whatapply
accomplishes more safely.- Definition Classes
- ErrorGen
- Since
4.4.0
- def reason(x: A): Option[String]
What should the reason component of the error message be (if any) based on the result the offending parser produced?
What should the reason component of the error message be (if any) based on the result the offending parser produced?
- Since
4.4.0
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- def unexpected(x: A): UnexpectedItem
What should the unexpected component of the error message be based on the result the offending parser produced?
What should the unexpected component of the error message be based on the result the offending parser produced?
- Since
4.4.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()
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.