scala-parser-combinators/scala.util.parsing.combinator/Parsers/OnceParser

OnceParser

trait OnceParser[+T] extends Parser[T]
A parser whose ~ combinator disallows back-tracking.
class Parser[T]
trait Input => ParseResult[T]
class Object
trait Matchable
class Any

Value members

Methods

override def ~[U](p: => Parser[U]): Parser[T ~ U]
Definition Classes
override def ~>[U](p: => Parser[U]): Parser[U]
Definition Classes
override def <~[U](p: => Parser[U]): Parser[T]
Definition Classes

Inherited methods

def *[U >: T](sep: => Parser[(U, U) => U]): Parser[U]
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)
Inhertied from
Parser
def *: Parser[List[T]]
Returns a parser that repeatedly parses what this parser parses.
Returns
rep(this)
Inhertied from
Parser
def filter(p: T => Boolean): Parser[T]
Inhertied from
Parser
def apply(in: Input): ParseResult[T]
An unspecified method that defines the behaviour of this parser.
Inhertied from
Parser
def >>[U](fq: T => Parser[U]): Parser[U]
Returns into(fq).
Inhertied from
Parser
def -[U](q: Parser[U]): Parser[T]
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 of p (this parser) if it succeeds and q fails. If q succeeds, the parser will fail.
Inhertied from
Parser
def withFailureMessage(msg: String): Parser[T]
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.
Inhertied from
Parser
def flatMap[U](f: T => Parser[U]): Parser[U]
Inhertied from
Parser
def named(n: String): Parser
Inhertied from
Parser
@migration("The call-by-name argument is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.", "2.9.0")
def ~>![U](q: => Parser[U]): Parser[U]
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 of q.
The resulting parser fails if either p or q fails, this failure is fatal.
Inhertied from
Parser
def withFilter(p: T => Boolean): Parser[T]
Inhertied from
Parser
def map[U](f: T => U): Parser[U]
Inhertied from
Parser
def |[U >: T](q: => Parser[U]): Parser[U]
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).
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 of p and q)
The resulting parser succeeds if (and only if)
- p succeeds, ''or''
- if p fails allowing back-tracking and q succeeds.
Inhertied from
Parser
def withErrorMessage(msg: String): Parser[T]
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.
Inhertied from
Parser
@migration("The call-by-name argument is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.", "2.9.0")
def append[U >: T](p0: => Parser[U]): Parser[U]
Inhertied from
Parser
def into[U](fq: T => Parser[U]): Parser[U]
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 then fq(x) succeeds
Example
{{{
def perlRE = "m" ~> (".".r into (separator => """[^%s] *""".format(separator).r <~ separator))
}}}
Inhertied from
Parser
override def toString: String
Definition Classes
Parser -> Function1 -> Any
Inhertied from
Parser
def +: Parser[List[T]]
Returns a parser that repeatedly (at least once) parses what this parser parses.
Returns
rep1(this)
Inhertied from
Parser
@unspecialized
def andThen[A](g: R => A): T1 => A
Inhertied from
Function1
@migration("The call-by-name argument is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.", "2.9.0")
def ^^^[U](v: => U): Parser[U]
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 if p fails.
Returns
a parser that has the same behaviour as the current parser, but whose successful result is v
Inhertied from
Parser
@migration("The call-by-name argument is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.", "2.9.0")
def |||[U >: T](q0: => Parser[U]): Parser[U]
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 of p and q).
Inhertied from
Parser
@unspecialized
def compose[A](g: A => T1): A => R
Inhertied from
Function1
def ^^[U](f: T => U): Parser[U]
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 in ParseResult).
Returns
a parser that has the same behaviour as the current parser, but whose result is
transformed by f.
Inhertied from
Parser
def ~![U](p: => Parser[U]): Parser[T ~ U]
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 of p and that of q.
The resulting parser fails if either p or q fails, this failure is fatal.
Inhertied from
Parser
def ^?[U](f: PartialFunction[T, U]): Parser[U]
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 in ParseResult).
Returns
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.
Inhertied from
Parser
def ^?[U](f: PartialFunction[T, U], error: T => String): Parser[U]
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 why f wasn't applicable
f
a partial function that will be applied to this parser's result
(see mapPartial in ParseResult).
Returns
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.
Inhertied from
Parser
@migration("The call-by-name argument is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.", "2.9.0")
def <~![U](q: => Parser[U]): Parser[T]
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 of p.
The resulting parser fails if either p or q fails, this failure is fatal.
Inhertied from
Parser
def ?: Parser[Option[T]]
Returns a parser that optionally parses what this parser parses.
Returns
opt(this)
Inhertied from
Parser