JavaTokenParsers

type Elem = Char

the type of input elements the provided parsers consume (When consuming invidual characters, a parser is typically called a scanner, which produces tokens that are consumed by what is normally called a parser. Nonetheless, the same principles apply, regardless of the input type.)

class Error(msg: String, next: Reader[Elem]) extends NoSuccess with Product

The fatal failure case of ParseResult: contains an error-message and the remaining input .

class Failure(msg: String, next: Reader[Elem]) extends NoSuccess with Product

The failure case of ParseResult: contains an error-message and the remaining input .

type Input = Reader[Char]

The parser input is an abstract reader of input elements, i .

class NoSuccess extends ParseResult[Nothing]

A common super-class for unsuccessful parse results

trait OnceParser[+T] extends Parser[T]

A parser whose ~ combinator disallows back-tracking .

class ParseResult[+T] extends AnyRef

A base class for parser results .

class Parser[+T] extends (Reader[Elem]) ⇒ ParseResult[T]

The root class of parsers .

class Success[+T](result: T, next: Reader[Elem]) extends ParseResult[T] with Product

The success case of ParseResult: contains the result and the remaining input .

class ~[+a, +b](_1: a, _2: b) extends Product

def !=(arg0: AnyRef): Boolean

def !=(arg0: Any): Boolean

o != arg0 is the same as !(o == (arg0)).

def ##(): Int

def $asInstanceOf[T0](): T0

def $isInstanceOf[T0](): Boolean

def ==(arg0: AnyRef): Boolean

o == arg0 is the same as if (o eq null) arg0 eq null else o.equals(arg0).

def ==(arg0: Any): Boolean

o == arg0 is the same as o.equals(arg0).

object NoSuccess extends AnyRef

An extractor so NoSuccess(msg, next) can be used in matches .

def OnceParser[T](f: (Reader[Char]) ⇒ ParseResult[T]): Parser[T] with OnceParser[T]

def Parser[T](f: (Reader[Char]) ⇒ ParseResult[T]): Parser[T]

def accept[U](expected: String, f: PartialFunction[Char, U]): Parser[U]

The parser that matches an element in the domain of the partial function f' If f' is defined on the first element in the input, f' is applied to it to produce this parser's result. Example: The parser accept("name", {case Identifier(n) => Name(n)}) accepts an Identifier(n) and returns a Name(n).

def accept[ES](es: ES)(implicit arg0: (ES) ⇒ List[Char]): Parser[List[Char]]

A parser that matches only the given list of element es' accept(es) succeeds if the input subsequently provides the elements in the list es'.

implicit def accept(e: Char): Parser[Char]

A parser that matches only the given element e' The method is implicit so that elements can automatically be lifted to their parsers. For example, when parsing Token's, Identifier("new") (which is a Token') can be used directly, instead of first creating a Parser' using accept(Identifier("new")).

def acceptIf(p: (Char) ⇒ Boolean)(err: (Char) ⇒ String): Parser[Char]

def acceptMatch[U](expected: String, f: PartialFunction[Char, U]): Parser[U]

def acceptSeq[ES](es: ES)(implicit arg0: (ES) ⇒ Iterable[Char]): Parser[List[Char]]

def asInstanceOf[T0]: T0

This method is used to cast the receiver object to be of type T0.

def chainl1[T, U](first: ⇒ Parser[T], p: ⇒ Parser[U], q: ⇒ Parser[(T, U) ⇒ T]): Parser[T]

A parser generator that, roughly, generalises the rep1sep generator so that q', which parses the separator, produces a left-associative function that combines the elements it separates.

def chainl1[T](p: ⇒ Parser[T], q: ⇒ Parser[(T, T) ⇒ T]): Parser[T]

A parser generator that, roughly, generalises the rep1sep generator so that q', which parses the separator, produces a left-associative function that combines the elements it separates. From: J. Fokker. Functional parsers. In J. Jeuring and E. Meijer, editors, Advanced Functional Programming, volume 925 of Lecture Notes in Computer Science, pages 1--23. Springer, 1995.

def chainr1[T, U](p: ⇒ Parser[T], q: ⇒ Parser[(T, U) ⇒ U], combine: (T, U) ⇒ U, first: U): Parser[U]

A parser generator that generalises the rep1sep generator so that q', which parses the separator, produces a right-associative function that combines the elements it separates. Additionally, The right-most (last) element and the left-most combining function have to be supplied. rep1sep(p: Parser[T], q) corresponds to chainr1(p, q ^^ cons, cons, Nil) (where val cons = (x: T, y: List[T]) => x :: y)

def clone(): AnyRef

This method creates and returns a copy of the receiver object .

def commit[T](p: ⇒ Parser[T]): Parser[T]

Wrap a parser so that its failures become errors (the | combinator will give up as soon as it encounters an error, on failure it simply tries the next alternative)

def decimalNumber: Parser[String]

def elem(e: Char): Parser[Char]

A parser that matches only the given element e' elem(e) succeeds if the input starts with an element e'

def elem(kind: String, p: (Char) ⇒ Boolean): Parser[Char]

A parser matching input elements that satisfy a given predicate

def eq(arg0: AnyRef): Boolean

This method is used to test whether the argument (arg0) is a reference to the receiver object (this).

def equals(arg0: Any): Boolean

This method is used to compare the receiver object (this) with the argument object (arg0) for equivalence.

def err(msg: String): Parser[Nothing]

A parser that results in an error

def failure(msg: String): Parser[Nothing]

A parser that always fails

def finalize(): Unit

This method is called by the garbage collector on the receiver object when garbage collection determines that there are no more references to the object .

def floatingPointNumber: Parser[String]

def getClass(): java.lang.Class[_ <: java.lang.Object]

Returns a representation that corresponds to the dynamic class of the receiver object .

def guard[T](p: ⇒ Parser[T]): Parser[T]

A parser generator for guard expressions .

def handleWhiteSpace(source: CharSequence, offset: Int): Int

def hashCode(): Int

Returns a hash code value for the object .

def ident: Parser[String]

def isInstanceOf[T0]: Boolean

This method is used to test whether the dynamic type of the receiver object is T0.

var lastNoSuccess: NoSuccess

implicit def literal(s: String): Parser[String]

A parser that matches a literal string

def log[T](p: ⇒ Parser[T])(name: String): Parser[T]

def mkList[T]: (~[T, List[T]]) ⇒ List[T]

def ne(arg0: AnyRef): Boolean

o.ne(arg0) is the same as !(o.eq(arg0)).

def not[T](p: ⇒ Parser[T]): Parser[Unit]

Wrap a parser so that its failures&errors become success and vice versa -- it never consumes any input

def notify(): Unit

Wakes up a single thread that is waiting on the receiver object's monitor .

def notifyAll(): Unit

Wakes up all threads that are waiting on the receiver object's monitor .

def opt[T](p: ⇒ Parser[T]): Parser[Option[T]]

A parser generator for optional sub-phrases .

def parse[T](p: Parser[T], in: Reader): ParseResult[T]

Parse some prefix of reader in' with parser p'

def parse[T](p: Parser[T], in: CharSequence): ParseResult[T]

Parse some prefix of character sequence in' with parser p'

def parse[T](p: Parser[T], in: Reader[Char]): ParseResult[T]

Parse some prefix of reader in' with parser p'

def parseAll[T](p: Parser[T], in: CharSequence): ParseResult[T]

Parse all of character sequence in' with parser p'

def parseAll[T](p: Parser[T], in: Reader): ParseResult[T]

Parse all of reader in' with parser p'

def parseAll[T](p: Parser[T], in: Reader[Char]): ParseResult[T]

Parse all of reader in' with parser p'

def phrase[T](p: Parser[T]): Parser[T]

A parser generator delimiting whole phrases (i .

def positioned[T <: Positional](p: ⇒ Parser[T]): Parser[T]

positioned' decorates a parser's result with the start position of the input it consumed. If whitespace is being skipped, then it is skipped before the start position is recorded.

implicit def regex(r: Regex): Parser[String]

A parser that matches a regex string

def rep[T](p: ⇒ Parser[T]): Parser[List[T]]

A parser generator for repetitions .

def rep1[T](first: ⇒ Parser[T], p: ⇒ Parser[T]): Parser[List[T]]

A parser generator for non-empty repetitions .

def rep1[T](p: ⇒ Parser[T]): Parser[List[T]]

A parser generator for non-empty repetitions .

def rep1sep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

A parser generator for non-empty repetitions .

def repN[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

A parser generator for a specified number of repetitions .

def repsep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

A parser generator for interleaved repetitions .

def skipWhitespace: Boolean

def stringLiteral: Parser[String]

def success[T](v: T): Parser[T]

A parser that always succeeds

def synchronized[T0](arg0: T0): T0

def toString(): String

Returns a string representation of the object .

def wait(): Unit

def wait(arg0: Long, arg1: Int): Unit

def wait(arg0: Long): Unit

val whiteSpace: Regex

def wholeNumber: Parser[String]