Scala Library
scala.util.parsing.combinator.Parsers

class Parser
[source: scala/util/parsing/combinator/Parsers.scala]
abstract class Parser[+T]
extends (Reader) => ParseResult[T]
The root class of parsers. Parsers are functions from the Input type to ParseResult
Direct Known Subclasses:
Parsers.OnceParser
Method Summary
def * : Parser[List[T]]
Returns a parser that repeatedly parses what this parser parses
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.
def + : Parser[List[T]]
Returns a parser that repeatedly (at least once) parses what this parser parses.
def <~ [U](p : => Parser[U]) : Parser[T]
A parser combinator for sequential composition which keeps only the left result
def >> [U](fq : (T) => Parser[U]) : Parser[U]
Returns into(fq)
def ? : Parser[Option[T]]
Returns a parser that optionally parses what this parser parses.
def ^? [U](f : PartialFunction[T, U], error : (T) => java.lang.String) : Parser[U]
A parser combinator for partial function application
def ^? [U](f : PartialFunction[T, U]) : Parser[U]
A parser combinator for partial function application
def ^^ [U](f : (T) => U) : Parser[U]
A parser combinator for function application
def ^^^ [U](r : U) : Parser[U]
def append [U >: T](p : => Parser[U]) : Parser[U]
abstract def apply (in : Reader) : ParseResult[T]
An unspecified method that defines the behaviour of this parser.
def flatMap [U](f : (T) => Parser[U]) : Parser[U]
def into [U](fq : (T) => Parser[U]) : Parser[U]
A parser combinator that parameterises a subsequent parser with the result of this one
def map [U](f : (T) => U) : Parser[U]
def named (n : java.lang.String) : Parser[T]
override def toString : java.lang.String
Returns a string representation of the object.
def | [U >: T](q : => Parser[U]) : Parser[U]
A parser combinator for alternative composition
def ||| [U >: T](q : => Parser[U]) : Parser[U]
A parser combinator for alternative with longest match composition
def ~ [U](p : => Parser[U]) : Parser[~[T, U]]
A parser combinator for sequential composition
def ~! [U](p : => Parser[U]) : Parser[~[T, U]]
A parser combinator for non-back-tracking sequential composition
def ~> [U](p : => Parser[U]) : Parser[U]
A parser combinator for sequential composition which keeps only the right result
Methods inherited from Function1
compose, andThen
Methods inherited from AnyRef
getClass, hashCode, equals, clone, notify, notifyAll, wait, wait, wait, finalize, ==, !=, eq, ne, synchronized
Methods inherited from Any
==, !=, isInstanceOf, asInstanceOf
Method Details
def named(n : java.lang.String) : Parser[T]
override def toString : java.lang.String
Returns a string representation of the object.

The default representation is platform dependent.

Returns
a string representation of the object.

Overrides
Function1.toString
abstract def apply(in : Reader) : ParseResult[T]
An unspecified method that defines the behaviour of this parser.
Overrides
Function1.apply
def flatMap[U](f : (T) => Parser[U]) : Parser[U]
def map[U](f : (T) => U) : Parser[U]
def append[U >: T](p : => Parser[U]) : Parser[U]
def ~[U](p : => Parser[U]) : Parser[~[T, U]]
A parser combinator for sequential composition

`p ~ q' succeeds if `p' succeeds and `q' succeeds on the input left over by `p'.

Parameters
q - 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.
def ~>[U](p : => Parser[U]) : Parser[U]
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'.

Parameters
q - a parser that will be executed after `p' (this parser) succeeds
Returns
a `Parser' that -- on success -- returns the result of `q'.
def <~[U](p : => Parser[U]) : Parser[T]
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'.

Note: <~ has lower operator precedence than ~ or ~>.
Parameters
q - a parser that will be executed after `p' (this parser) succeeds
Returns
a `Parser' that -- on success -- returns the result of `p'.
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).

Parameters
q - 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.
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 `p's failure is non-fatal (i.e., back-tracking is allowed).

Parameters
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.
def |||[U >: T](q : => 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.

Parameters
q - a parser that accepts if p consumes less characters.
Returns
a `Parser' that returns the result of the parser consuming the most characteres (out of `p' and `q').
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'.

Parameters
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'.
def ^^^[U](r : U) : Parser[U]
def ^?[U](f : PartialFunction[T, U], error : (T) => java.lang.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.

Parameters
f - a partial function that will be applied to this parser's result (see `mapPartial' in `ParseResult').
error - a function that takes the same argument as `f' and produces an error message to explain why `f' wasn't applicable
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'.
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'.

Parameters
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'.
def into[U](fq : (T) => Parser[U]) : Parser[U]
A parser combinator that parameterises 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.

Parameters
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
def >>[U](fq : (T) => Parser[U]) : Parser[U]
Returns into(fq)
def * : Parser[List[T]]
Returns a parser that repeatedly parses what this parser parses
Returns
rep(this)
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)
def + : Parser[List[T]]
Returns a parser that repeatedly (at least once) parses what this parser parses.
Returns
rep1(this)
def ? : Parser[Option[T]]
Returns a parser that optionally parses what this parser parses.
Returns
opt(this)
Scala Library