Parser
The root class of parsers. Parsers are functions from the Input type to ParseResult.
The root class of parsers. Parsers are functions from the Input type to ParseResult.
Value members
Abstract methods
Concrete methods
Returns a parser that repeatedly parses what this parser parses.
Returns a parser that repeatedly parses what this parser parses.
- Returns
rep(this)
Returns a parser that repeatedly parses what this parser parses,
interleaved with the sep
parser. The sep
parser specifies how
the results parsed by this parser should be combined.
Returns a parser that repeatedly parses what this parser parses,
interleaved with the sep
parser. The sep
parser specifies how
the results parsed by this parser should be combined.
- Returns
chainl1(this, sep)
Returns a parser that repeatedly (at least once) parses what this parser parses.
Returns a parser that repeatedly (at least once) parses what this parser parses.
- Returns
rep1(this)
A parser combinator for exceptions.
A parser combinator for exceptions.
p - q
succeeds if p
succeeds, and q
fails on the same input given p
.
- Value Params
- q
a parser that will be executed before
p
(this parser). q will not consume the input.
- Returns
a
Parser
that returns the result ofp
(this parser) if it succeeds and q fails. If q succeeds, the parser will fail.
A parser combinator for sequential composition which keeps only the left result.
A parser combinator for sequential composition which keeps only the left result.
p <~ q
succeeds if p
succeeds and q
succeeds on the input
left over by p
.
- Value Params
- q
a parser that will be executed after
p
(this parser) succeeds -- evaluated at most once, and only when necessary
- Returns
a
Parser
that -- on success -- returns the result ofp
.- Note
<~ has lower operator precedence than ~ or ~>.
A parser combinator for non-back-tracking sequential composition which only keeps the left result.
A parser combinator for non-back-tracking sequential composition which only keeps the left result.
p <~! q
succeeds if p
succeds and q
succeds on the input left over by p
.
In case of failure, no back-tracking is performed (in an earlier parser produced by the |
combinator).
- Value Params
- q
a parser that will be executed after
p
(this parser) succeeds -- evaluated at most once, and only when necessary
- Returns
a
Parser
that -- on success -- reutrns the result ofp
. The resulting parser fails if eitherp
orq
fails, this failure is fatal.
Returns a parser that optionally parses what this parser parses.
Returns a parser that optionally parses what this parser parses.
- Returns
opt(this)
A parser combinator for partial function application.
A parser combinator for partial function application.
p ^? (f, error)
succeeds if p
succeeds AND f
is defined at the result of p
;
in that case, it returns f
applied to the result of p
. If f
is not applicable,
error(the result of p
) should explain why.
- Value Params
- error
a function that takes the same argument as
f
and produces an error message to explain whyf
wasn't applicable- f
a partial function that will be applied to this parser's result (see
mapPartial
inParseResult
).
- Returns
a parser that succeeds if the current parser succeeds and
f
is applicable to the result. If so, the result will be transformed byf
.
A parser combinator for partial function application.
A parser combinator for partial function application.
p ^? f
succeeds if p
succeeds AND f
is defined at the result of p
;
in that case, it returns f
applied to the result of p
.
- Value Params
- f
a partial function that will be applied to this parser's result (see
mapPartial
inParseResult
).
- Returns
a parser that succeeds if the current parser succeeds and
f
is applicable to the result. If so, the result will be transformed byf
.
A parser combinator for function application.
A parser combinator for function application.
p ^^ f
succeeds if p
succeeds; it returns f
applied to the result of p
.
- Value Params
- f
a function that will be applied to this parser's result (see
map
inParseResult
).
- Returns
a parser that has the same behaviour as the current parser, but whose result is transformed by
f
.
A parser combinator that changes a successful result into the specified value.
A parser combinator that changes a successful result into the specified value.
p ^^^ v
succeeds if p
succeeds; discards its result, and returns v
instead.
- Value Params
- v
The new result for the parser, evaluated at most once (if
p
succeeds), not evaluated at all ifp
fails.
- Returns
a parser that has the same behaviour as the current parser, but whose successful result is
v
A parser combinator that parameterizes a subsequent parser with the result of this one.
A parser combinator that parameterizes a subsequent parser with the result of this one.
Use this combinator when a parser depends on the result of a previous
parser. p
should be a function that takes the result from the first
parser and returns the second parser.
p into fq
(with fq
typically {x => q}
) first applies p
, and
then, if p
successfully returned result r
, applies fq(r)
to the
rest of the input.
''From: G. Hutton. Higher-order functions for parsing. J. Funct. Program., 2(3):323--343, 1992.''
- Value Params
- fq
a function that, given the result from this parser, returns the second parser to be applied
- Returns
a parser that succeeds if this parser succeeds (with result
x
) and if thenfq(x)
succeeds- Example
def perlRE = "m" ~> (".".r into (separator => """[^%s]*""".format(separator).r <~ separator))
Changes the error message produced by a parser.
Changes the error message produced by a parser.
This doesn't change the behavior of a parser on neither
success nor failure, just on error. The semantics are
slightly different than those obtained by doing | error(msg)
,
in that the message produced by this method will always
replace the message produced, which is not guaranteed
by that idiom.
For example, parser p
below will always produce the
designated error message, while q
will not produce
it if sign
is parsed but number
is not.
def p = sign.? ~ number withErrorMessage "Number expected!"
def q = sign.? ~ number | error("Number expected!")
- Value Params
- msg
The message that will replace the default error message.
- Returns
A parser with the same properties and different error message.
Changes the failure message produced by a parser.
Changes the failure message produced by a parser.
This doesn't change the behavior of a parser on neither
success nor error, just on failure. The semantics are
slightly different than those obtained by doing | failure(msg)
,
in that the message produced by this method will always
replace the message produced, which is not guaranteed
by that idiom.
For example, parser p
below will always produce the
designated failure message, while q
will not produce
it if sign
is parsed but number
is not.
def p = sign.? ~ number withFailureMessage "Number expected!"
def q = sign.? ~ number | failure("Number expected!")
- Value Params
- msg
The message that will replace the default failure message.
- Returns
A parser with the same properties and different failure message.
A parser combinator for alternative composition.
A parser combinator for alternative composition.
p | q
succeeds if p
succeeds or q
succeeds.
Note that q
is only tried if p
s failure is non-fatal (i.e., back-tracking is allowed).
- Value Params
- q
a parser that will be executed if
p
(this parser) fails (and allows back-tracking)
- Returns
a
Parser
that returns the result of the first parser to succeed (out ofp
andq
) The resulting parser succeeds if (and only if) -p
succeeds, ''or'' - ifp
fails allowing back-tracking andq
succeeds.
A parser combinator for alternative with longest match composition.
A parser combinator for alternative with longest match composition.
p ||| q
succeeds if p
succeeds or q
succeeds.
If p
and q
both succeed, the parser that consumed the most characters accepts.
- Value Params
- q0
a parser that accepts if p consumes less characters. -- evaluated at most once, and only when necessary
- Returns
a
Parser
that returns the result of the parser consuming the most characters (out ofp
andq
).
A parser combinator for sequential composition.
A parser combinator for sequential composition.
p ~ q
succeeds if p
succeeds and q
succeeds on the input left over by p
.
- Value Params
- q
a parser that will be executed after
p
(this parser) succeeds -- evaluated at most once, and only when necessary.
- Returns
a
Parser
that -- on success -- returns a~
(like aPair
, but easier to pattern match on) that contains the result ofp
and that ofq
. The resulting parser fails if eitherp
orq
fails.
A parser combinator for non-back-tracking sequential composition.
A parser combinator for non-back-tracking sequential composition.
p ~! q
succeeds if p
succeeds and q
succeeds on the input left over by p
.
In case of failure, no back-tracking is performed (in an earlier parser produced by the |
combinator).
- Value Params
- p
a parser that will be executed after
p
(this parser) succeeds
- Returns
a
Parser
that -- on success -- returns a~
(like a Pair, but easier to pattern match on) that contains the result ofp
and that ofq
. The resulting parser fails if eitherp
orq
fails, this failure is fatal.
A parser combinator for sequential composition which keeps only the right result.
A parser combinator for sequential composition which keeps only the right result.
p ~> q
succeeds if p
succeeds and q
succeeds on the input left over by p
.
- Value Params
- q
a parser that will be executed after
p
(this parser) succeeds -- evaluated at most once, and only when necessary.
- Returns
a
Parser
that -- on success -- returns the result ofq
.
A parser combinator for non-back-tracking sequential composition which only keeps the right result.
A parser combinator for non-back-tracking sequential composition which only keeps the right result.
p ~>! q
succeeds if p
succeds and q
succeds on the input left over by p
.
In case of failure, no back-tracking is performed (in an earlier parser produced by the |
combinator).
- Value Params
- q
a parser that will be executed after
p
(this parser) succeeds -- evaluated at most once, and only when necessary
- Returns
a
Parser
that -- on success -- reutrns the result ofq
. The resulting parser fails if eitherp
orq
fails, this failure is fatal.