Scala Library Documentation


abstract
class
Parser[+T]
extends
(Reader) => ParseResult[T]Method Summary  
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 parses what this parser parses

def

*
[Q](sep : => Q)(implicit view$3 : (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 (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) => 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. 
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. Higherorder functions for parsing. J. Funct. Program., 2(3):323343, 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 nonfatal (i.e., backtracking is allowed). 
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. 
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$1 : (Q) => UnitParser) : Parser[T]
A parser combinator for sequential composition with a unitparser
`p ~ q' succeeds if `p' succeeds and `q' succeeds on the input left over by `p'. 
def

~!
[Q](q : => Q)(implicit view$2 : (Q) => UnitParser) : Parser[T]
A parser combinator for nonbacktracking sequential composition with a unitparser
`p ~! q' succeeds if `p' succeeds and `q' succeeds on the input left over by `p'. In case of failure, no backtracking is performed (in an earlier parser produced by the  combinator). 
def

~!
[U](q : => Parser[U]) : Parser[~[T, U]]
A parser combinator for nonbacktracking sequential composition
`p ~! q' succeeds if `p' succeeds and `q' succeeds on the input left over by `p'. In case of failure, no backtracking 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]
`p ~ q' succeeds if `p' succeeds and `q' succeeds on the input left over by `p'.
q 
a parser that will be executed after `p' (this parser) succeeds
def
~[Q](q : => Q)(implicit
view$1 : (Q) => UnitParser) : Parser[T]
`p ~ q' succeeds if `p' succeeds and `q' succeeds on the input left over by `p'.
q 
a parser (convertible to a UnitParser) that will be executed after `p' (this parser) succeeds`p ~! q' succeeds if `p' succeeds and `q' succeeds on the input left over by `p'. In case of failure, no backtracking is performed (in an earlier parser produced by the  combinator).
q 
a parser that will be executed after `p' (this parser) succeeds
def
~![Q](q : => Q)(implicit
view$2 : (Q) => UnitParser) : Parser[T]
`p ~! q' succeeds if `p' succeeds and `q' succeeds on the input left over by `p'. In case of failure, no backtracking is performed (in an earlier parser produced by the  combinator).
q 
a parser that will be executed after `p' (this parser) succeeds`p  q' succeeds if `p' succeeds or `q' succeeds Note that `q' is only tried if `p's failure is nonfatal (i.e., backtracking is allowed).
q 
a parser that will be executed if `p' (this parser) fails (and allows backtracking)`p  q' succeeds if `p' succeeds or `q' succeeds If `p' and `q' both succeed, the parser that consumed the most characters accepts.
q 
a parser that accepts if p consumes less characters.`p ^^ f' succeeds if `p' succeeds; it returns `f' applied to the result of `p'.
f 
a function that will be applied to this parser's result (see `map' in `ParseResult').
def
^?[U](f : PartialFunction[T, U], error : (T) => java.lang.String) : Parser[U]
`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.
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
def
^?[U](f : PartialFunction[T, U]) : Parser[U]
`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'.
f 
a partial function that will be applied to this parser's result (see `mapPartial' in `ParseResult').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. Higherorder functions for parsing. J. Funct. Program., 2(3):323343, 1992.
fq 
a function that, given the result from this parser, returns the second parser to be applied
Scala Library Documentation

