implicit final class EagerOps[T] extends AnyVal
- Alphabetic
- By Inheritance
- EagerOps
- AnyVal
- Any
- Hide All
- Show All
- Public
- All
Value Members
-
macro
def
!(implicit ctx: P[Any]): P[String]
Capture operator; makes the parser return the span of input it parsed as a String, which can then be processed further using ~, map or flatMapX
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- Any
-
final
def
##(): Int
- Definition Classes
- Any
-
macro
def
/(implicit ctx: P[_]): P[T]
Plain cut operator.
Plain cut operator. Runs the parser, and if it succeeds, backtracking past that point is now prohibited
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- Any
-
macro
def
?[V](implicit optioner: Optioner[T, V], ctx: P[Any]): P[V]
Optional operator.
Optional operator. Parses the given input to wrap it in a
Some
, but if parsing fails backtracks and returnsNone
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
macro
def
filter(f: (T) ⇒ Boolean)(implicit ctx: P[Any]): P[T]
Tests the output of the parser with a given predicate, failing the parse if the predicate returns false.
Tests the output of the parser with a given predicate, failing the parse if the predicate returns false. Useful for doing local validation on bits and pieces of your parsed output
-
macro
def
flatMap[V](f: (T) ⇒ P[V])(implicit whitespace: (P[Any]) ⇒ P[Unit]): P[V]
Transforms the result of this parser using the given function into a new parser which is applied (after whitespace).
Transforms the result of this parser using the given function into a new parser which is applied (after whitespace). Useful for doing dependent parsing, e.g. when parsing JSON you may first parse a character to see if it's a
[
,{
, or"
, and then deciding whether you next want to parse an array, dictionary or string. -
macro
def
flatMapX[V](f: (T) ⇒ P[V]): P[V]
Transforms the result of this parser using the given function into a new parser which is applied (without consuming whitespace).
Transforms the result of this parser using the given function into a new parser which is applied (without consuming whitespace). Useful for doing dependent parsing, e.g. when parsing JSON you may first parse a character to see if it's a
[
,{
, or"
, and then deciding whether you next want to parse an array, dictionary or string. -
def
getClass(): Class[_ <: AnyVal]
- Definition Classes
- AnyVal → Any
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
macro
def
map[V](f: (T) ⇒ V): P[V]
Transforms the result of this parser using the given function.
Transforms the result of this parser using the given function. Useful for turning the Strings captured by ! and the tuples built by ~ into your own case classes or data structure
- val parse0: P[T]
-
def
toString(): String
- Definition Classes
- Any
-
macro
def
|[V >: T](other: P[V])(implicit ctx: P[Any]): P[V]
Either-or operator: tries to parse the left-hand-side, and if that fails it backtracks and tries to pass the right-hand-side.
Either-or operator: tries to parse the left-hand-side, and if that fails it backtracks and tries to pass the right-hand-side. Can be chained more than once to parse larger numbers of alternatives.
-
macro
def
~[V, R](other: P[V])(implicit s: Sequencer[T, V, R], whitespace: (P[Any]) ⇒ P[Unit], ctx: P[_]): P[R]
Sequence operator.
Sequence operator. Runs two parsers one after the other, with optional whitespace in between.If both parsers return a value, this returns a tuple.
-
macro
def
~/[V, R](other: P[V])(implicit s: Sequencer[T, V, R], whitespace: (P[Any]) ⇒ P[Unit], ctx: P[_]): P[R]
Sequence-with-cut operator.
Sequence-with-cut operator. Runs two parsers one after the other, with optional whitespace in between. If the first parser completes successfully, backtracking is now prohibited. If both parsers return a value, this returns a tuple.
-
macro
def
~~[V, R](other: P[V])(implicit s: Sequencer[T, V, R], ctx: P[_]): P[R]
Raw sequence operator.
Raw sequence operator. Runs two parsers one after the other, *without* whitespace in between. If both parsers return a value, this returns a tuple.
-
macro
def
~~/[V, R](other: P[V])(implicit s: Sequencer[T, V, R], ctx: P[_]): P[R]
Raw sequence-with-cut operator.
Raw sequence-with-cut operator. Runs two parsers one after the other, *without* whitespace in between. If the first parser completes successfully, backtracking is no longer prohibited. If both parsers return a value, this returns a tuple.