Parser

abstract def parse(input: TokenIterator): ParseResult[Result]

final def !=(arg0: Any): Boolean

final def ##(): Int

def *(): Parser[List[Result]]

r.* applies r zero or more times and returns a list of the results.

def +(): Parser[List[Result]]

r.+ applies r one or more times and returns a list of the results.

def <~[Result2](rhs: ⇒ Parser[Result2]): Parser[Result]

lhs <~ rhs applies lhs followed by rhs and returns the result of lhs.

final def ==(arg0: Any): Boolean

def ?(): Parser[Option[Result]]

r.? optionally matches r, producing Some(res) as the result if r succeeds with the result res or None if r fails.

def ^^[Result2](f: (Result) ⇒ Result2): Parser[Result2]

Applies f to the result of this rule if this rule is matched successfully and yields the result of f as the result of the rule.

def ^^ ⇒ Result2): Parser[Result2]

Applies f to the result of this rule and the location of the match if this rule is matched successfully and yields the result of f as the result of the rule.

def ^^^[Result2](exp: ⇒ Result2): Parser[Result2]

If this rule matches, return a successful result containing the given, lazily evaluated, expression.

def ^^^ ⇒ Result2): Parser[Result2]

Applies f to the location of the match if this rule is matched successfully and yields the result of f as the result of the rule.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def mockParse(input: Token): ParseResult[Result]

Pretend we're parsing a token stream that contains just this one token.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def |[Result2 >: Result](rhs: ⇒ Parser[Result2]): Parser[Result2]

lhs | rhs first tries to apply the rule lhs.

def ~[Result2](rhs: ⇒ Parser[Result2]): Parser[(Result, Result2)]

lhs ~ rhs applies lhs followed by rhs (if lhs was successful).

def ~>[Result2](rhs: ⇒ Parser[Result2]): Parser[Result2]

lhs ~> rhs applies lhs followed by rhs and returns the result of rhs.

def ~^[Result2](rhs: (Result) ⇒ Parser[Result2]): Parser[Result2]

lhs ~^ (r => rhs(r)) applies lhs followed by rhs(r) (if lhs was successful, r is the result of lhs). The final result will be the result of rhs(r).