implicit final class ErrorMethods[P, +A] extends AnyRef
This class exposes helpful combinators that are specialised for generating more helpful errors messages. For a description of why the library is designed in this way, see: the Parsley wiki
- Version
3.0.0
- Alphabetic
- By Inheritance
- ErrorMethods
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
Value Members
-
def
!(msggen: (A) ⇒ String): Parsley[Nothing]
Same as
fail, except allows for a message generated from the result of the failed parser.Same as
fail, except allows for a message generated from the result of the failed parser. In essence, this is equivalent top >>= (x => fail(msggen(x))but requires no expensive computations from the use of>>=.- msggen
The generator function for error message, creating a message based on the result of invokee
- returns
A parser that fails if it succeeds, with the given generator used to produce the error message
-
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
?(msg: String): Parsley[A]
Alias for
labelAlias for
label- Since
3.0.0
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
collectMsg[B](msggen: (A) ⇒ String)(pf: PartialFunction[A, B]): Parsley[B]
Attempts to first filter the parser to ensure that
pfis defined over it.Attempts to first filter the parser to ensure that
pfis defined over it. If it is, then the functionpfis mapped over its result. Roughly the same as aguardthen amap.- msggen
Generator function for error message, generating a message based on the result of the parser
- pf
The partial function
- returns
The result of applying
pfto this parsers value (if possible), or fails
- Since
3.0.0
-
def
collectMsg[B](msg: String)(pf: PartialFunction[A, B]): Parsley[B]
Attempts to first filter the parser to ensure that
pfis defined over it.Attempts to first filter the parser to ensure that
pfis defined over it. If it is, then the functionpfis mapped over its result. Roughly the same as aguardthen amap.- msg
The message used for the error if the input failed the check
- pf
The partial function
- returns
The result of applying
pfto this parsers value (if possible), or fails
- Since
3.0.0
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
explain(reason: String): Parsley[A]
Similar to
label, except instead of providing an expected message replacing the original tag, this combinator adds a reason that the error occurred.Similar to
label, except instead of providing an expected message replacing the original tag, this combinator adds a reason that the error occurred. This is in complement to the label. Thereasonis only added when the parser fails, and will disappear if any further progress in the parser is made (unlike labels, which may reappear as "hints").- reason
The reason why a parser failed
- Since
3.0.0
-
def
filterOut(pred: PartialFunction[A, String]): Parsley[A]
Filter the value of a parser; if the value returned by the parser is defined for the given partial function, then the
filterOutfails, using the result of the function as the reason (see explain), otherwise the parser succeedsFilter the value of a parser; if the value returned by the parser is defined for the given partial function, then the
filterOutfails, using the result of the function as the reason (see explain), otherwise the parser succeeds- pred
The predicate that is tested against the parser result
- returns
The result of the invokee if the value failed the predicate
- Since
3.0.0
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
guardAgainst(pred: PartialFunction[A, String]): Parsley[A]
Similar to
filterOut, except the error message generated yields a true failure.Similar to
filterOut, except the error message generated yields a true failure. This means that it will uses the same mechanism as fail, as opposed to the reason provided by filterOut- pred
The predicate that is tested against the parser result and produces error messages
- returns
The result of the invokee if it fails the predicate
- Since
2.8.0
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hide: Parsley[A]
Hides the "expected" error message for a parser.
Hides the "expected" error message for a parser.
- Since
3.0.0
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
label(msg: String): Parsley[A]
Sets the expected message for a parser.
Sets the expected message for a parser. If the parser fails then
expected msgwill added to the error- Since
3.0.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()
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
unexpected(msggen: (A) ⇒ String): Parsley[Nothing]
Same as
unexpected, except allows for a message generated from the result of the failed parser.Same as
unexpected, except allows for a message generated from the result of the failed parser. In essence, this is equivalent top >>= (x => unexpected(x))but requires no expensive computations from the use of>>=- msggen
The generator function for error message, creating a message based on the result of invokee
- returns
A parser that fails if it succeeds, with the given generator used to produce an unexpected message
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
This is the documentation for Parsley.
Package structure
The parsley package contains the
Parsleyclass, as well as theResult,Success, andFailuretypes. 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.Parsleycontains the bulk of the core "function-style" combinators, as well as the implicit classes which enable the "method-style" combinators.parsley.combinatorcontains many helpful combinators that simplify some common parser patterns.parsley.charactercontains the combinators needed to read characters and strings, as well as combinators to match specific sub-sets of characters.parsley.debugcontains debugging combinators, helpful for identifying faults in parsers.parsley.iocontains extension methods to run parsers with input sourced from IO sources.parsley.exprcontains the following sub modules:parsley.expr.chaincontains combinators used in expression parsingparsley.expr.precedenceis a builder for expression parsers built on a precedence table.parsley.implicitscontains several implicits to add syntactic sugar to the combinators. These are sub-categorised into the following sub modules:parsley.implicits.charactercontains implicits to allow you to use character and string literals as parsers.parsley.implicits.combinatorcontains implicits related to combinators, such as the ability to make any parser into aParsley[Unit]automatically.parsley.implicits.liftenables postfix application of the lift combinator onto a function (or value).parsley.implicits.zippedenables 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.zippedmethod for building tuples out of several combinators.parsley.errorscontains modules to deal with error messages, their refinement and generation.parsley.errors.combinatorprovides combinators that can be used to either produce more detailed errors as well as refine existing errors.parsley.liftcontains 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.registerscontains combinators that interact with the context-sensitive functionality in the form of registers.parsley.tokencontains theLexerclass that provides a host of helpful lexing combinators when provided with the description of a language.parsley.unsafecontains unsafe (and not thread-safe) ways of speeding up the execution of a parser.