scala-parser-combinators
API
Generated with
scala-parser-combinators/scala.util.parsing.combinator/Parsers/OnceParser

OnceParser

scala.util.parsing.combinator.Parsers.OnceParser
trait OnceParser[+T] extends Parser[T]

A parser whose ~ combinator disallows back-tracking.

Attributes

Graph
Supertypes
class Parser[T]
trait Input => ParseResult[T]
class Object
trait Matchable
class Any

Members list

Concise view

Value members

Concrete methods

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

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.

Attributes

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 of p.

Note:

<~ has lower operator precedence than ~ or ~>.

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

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.

Attributes

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 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.

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

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.

Attributes

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 of q.

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 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.

Attributes

Returns:

chainl1(this, sep)

Inherited from:
Parser
def *: Parser[List[T]]

Returns a parser that repeatedly parses what this parser parses.

Returns a parser that repeatedly parses what this parser parses.

Attributes

Returns:

rep(this)

Inherited from:
Parser
def +: Parser[List[T]]

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.

Attributes

Returns:

rep1(this)

Inherited from:
Parser
def -[U](q: Parser[U]): Parser[T]

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.

Attributes

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.

Inherited from:
Parser
def <~![U](q: => Parser[U]): Parser[T]

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 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).

Attributes

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.

Inherited from:
Parser
def >>[U](fq: T => Parser[U]): Parser[U]

Returns into(fq).

Returns into(fq).

Attributes

Inherited from:
Parser
def ?: Parser[Option[T]]

Returns a parser that optionally parses what this parser parses.

Returns a parser that optionally parses what this parser parses.

Attributes

Returns:

opt(this)

Inherited from:
Parser
def ^?[U](f: PartialFunction[T, U]): Parser[U]

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.

Attributes

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.

Inherited from:
Parser
def ^?[U](f: PartialFunction[T, U], error: T => String): Parser[U]

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.

Attributes

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.

Inherited from:
Parser
def ^^[U](f: T => U): Parser[U]

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.

Attributes

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.

Inherited from:
Parser
def ^^^[U](v: => U): Parser[U]

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.

Attributes

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

Inherited from:
Parser
def andThen[A](g: ParseResult[T] => A): T1 => A

Attributes

Inherited from:
Function1
def append[U >: T](p0: => Parser[U]): Parser[U]

Attributes

Inherited from:
Parser
def apply(in: Input): ParseResult[T]

An unspecified method that defines the behaviour of this parser.

An unspecified method that defines the behaviour of this parser.

Attributes

Inherited from:
Parser
def compose[A](g: A => Input): A => R

Attributes

Inherited from:
Function1
def filter(p: T => Boolean): Parser[T]

Attributes

Inherited from:
Parser
def flatMap[U](f: T => Parser[U]): Parser[U]

Attributes

Inherited 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.

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.''

Attributes

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))
Inherited from:
Parser
def map[U](f: T => U): Parser[U]

Attributes

Inherited from:
Parser
def named(n: String): Parser.this.type

Attributes

Inherited from:
Parser
override def toString: String

Returns a string representation of the object.

Returns a string representation of the object.

The default representation is platform dependent.

Attributes

Returns:

a string representation of the object.

Definition Classes
Parser -> Function1 -> Any
Inherited from:
Parser
def withErrorMessage(msg: String): Parser[T]

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!")

Attributes

msg

The message that will replace the default error message.

Returns:

A parser with the same properties and different error message.

Inherited from:
Parser
def withFailureMessage(msg: String): Parser[T]

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!")

Attributes

msg

The message that will replace the default failure message.

Returns:

A parser with the same properties and different failure message.

Inherited from:
Parser
def withFilter(p: T => Boolean): Parser[T]

Attributes

Inherited from:
Parser
def |[U >: T](q: => Parser[U]): Parser[U]

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).

Attributes

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.

Inherited from:
Parser
def |||[U >: T](q0: => Parser[U]): Parser[U]

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.

Attributes

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).

Inherited from:
Parser
def ~![U](p: => Parser[U]): Parser[T ~ U]

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).

Attributes

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.

Inherited from:
Parser
def ~>![U](q: => Parser[U]): Parser[U]

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 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).

Attributes

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.

Inherited from:
Parser
Generated with