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 * [Q](sep : => Q)(implicit view$2 : (Q) => UnitParser) : Parser[List[T]]
Returns a parser that repeatedly parses what this parser parses, interleaved with the `sep' parser.
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](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]) : 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'.

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.

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

abstract def apply (in : Reader) : ParseResult[T]
An unspecified method that defines the behaviour of this parser.
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.

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

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

def ~ [Q](q : => Q)(implicit view$0 : (Q) => UnitParser) : Parser[T]
A parser combinator for sequential composition with a unit-parser

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

def ~! [Q](q : => Q)(implicit view$1 : (Q) => UnitParser) : Parser[T]
A parser combinator for non-back-tracking sequential composition with a unit-parser

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

def ~! [U](q : => 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).

Methods inherited from Function1
toString, 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
abstract def apply(in : Reader) : ParseResult[T]
An unspecified method that defines the behaviour of this parser.
Overrides
Function1.apply

def ~[U](q : => 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 ~[Q](q : => Q)(implicit view$0 : (Q) => UnitParser) : Parser[T]
A parser combinator for sequential composition with a unit-parser

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

Parameters
q - a parser (convertible to a UnitParser) that will be executed after `p' (this parser) succeeds
Returns
a `Parser' that -- on success -- returns the result of `p'. The resulting parser fails if either `p' or `q' fails.

def ~![U](q : => 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 ~![Q](q : => Q)(implicit view$1 : (Q) => UnitParser) : Parser[T]
A parser combinator for non-back-tracking sequential composition with a unit-parser

`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 the result of `p'. 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](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](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.

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 *[Q](sep : => Q)(implicit view$2 : (Q) => UnitParser) : Parser[List[T]]
Returns a parser that repeatedly parses what this parser parses, interleaved with the `sep' parser.
Returns
repsep(this, sep)

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)