scala.util.parsing.combinator.Parsers
An unspecified method that defines the behaviour of this parser.
An unspecified method that defines the behaviour of this parser.
Returns a parser that repeatedly parses what this parser parses,
interleaved with the sep
parser.
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.
chainl1(this, sep)
Returns a parser that repeatedly parses what this parser parses.
Returns a parser that repeatedly parses what this parser parses.
rep(this)
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.
rep1(this)
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
.
a parser that will be executed after p
(this parser) succeeds -- evaluated at most once, and only when necessary
a Parser
that -- on success -- returns the result of p
.
(Changed in version 2.9.0) The call-by-name argument is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.
<~ has lower operator precedence than ~ or ~>.
Returns into(fq)
.
Returns a parser that optionally parses what this parser parses.
Returns a parser that optionally parses what this parser parses.
opt(this)
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.
a partial function that will be applied to this parser's result
(see mapPartial
in ParseResult
).
a parser that succeeds if the current parser succeeds and f
is applicable
to the result. If so, the result will be transformed by f
.
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.
a partial function that will be applied to this parser's result
(see mapPartial
in ParseResult
).
a function that takes the same argument as f
and produces an error message
to explain why f
wasn't applicable
a parser that succeeds if the current parser succeeds and f
is applicable
to the result. If so, the result will be transformed by f
.
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.
a function that will be applied to this parser's result (see map
in ParseResult
).
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.
The new result for the parser, evaluated at most once (if p
succeeds), not evaluated at all if p
fails.
a parser that has the same behaviour as the current parser, but whose successful result is v
(Changed in version 2.9.0) The call-by-name argument is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.
(Changed in version 2.9.0) The call-by-name argument is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.
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.
a function that, given the result from this parser, returns the second parser to be applied
a parser that succeeds if this parser succeeds (with result x
)
and if then fq(x)
succeeds
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!")
The message that will replace the default error message.
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!")
The message that will replace the default failure message.
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).
a parser that will be executed if p
(this parser) fails (and allows back-tracking)
a Parser
that returns the result of the first parser to succeed (out of p
and q
)
The resulting parser succeeds if (and only if)
p
succeeds, orp
fails allowing back-tracking and q
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.
a parser that accepts if p consumes less characters. -- evaluated at most once, and only when necessary
a Parser
that returns the result of the parser consuming the most characters (out of p
and q
).
(Changed in version 2.9.0) The call-by-name argument is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.
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
.
a parser that will be executed after p
(this parser)
succeeds -- evaluated at most once, and only when necessary.
a Parser
that -- on success -- returns a ~
(like a Pair
,
but easier to pattern match on) that contains the result of p
and
that of q
. The resulting parser fails if either p
or q
fails.
(Changed in version 2.9.0) The call-by-name argument is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.
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).
a parser that will be executed after p
(this parser) succeeds
a Parser
that -- on success -- returns a ~
(like a Pair, but easier to pattern match on)
that contains the result of p
and that of q
.
The resulting parser fails if either p
or q
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
.
a parser that will be executed after p
(this parser)
succeeds -- evaluated at most once, and only when necessary.
a Parser
that -- on success -- returns the result of q
.
(Changed in version 2.9.0) The call-by-name argument is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.
(parser: StringAdd[Parser[T]]).+(other)
The root class of parsers. Parsers are functions from the Input type to ParseResult.