scala.util.parsing.combinator.Parsers
OnceParser
Related Doc:
package 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 exceptions.
A parser combinator for exceptions.
p - q succeeds if p succeeds, and q fails on the same input given p.
a parser that will be executed before p (this parser). q will not consume the input.
a Parser that returns the result of p (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.
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 ~>.
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).
a parser that will be executed after p (this parser) succeeds -- evaluated at most once, and only when necessary
a Parser that -- on success -- reutrns the result of p.
The resulting parser fails if either p or q fails, this failure is fatal.
(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.
Returns into(fq).
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 ps 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 -- 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.
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.
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).
a parser that will be executed after p (this parser) succeeds -- evaluated at most once, and only when necessary
a Parser that -- on success -- reutrns the result of q.
The resulting parser fails if either p or q fails, this failure is fatal.
(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 whose
~combinator disallows back-tracking.