Xml

abstract def Block: P0

abstract def Pattern: P0

abstract def Patterns: P0

final def !=(arg0: Any): Boolean

val #: Parser[Unit]

final def ##(): Int

val :: Parser[Unit]

val <%: Parser[Unit]

val <-: Parser[Unit]

val <:: Parser[Unit]

val =: Parser[Unit]

final def ==(arg0: Any): Boolean

val =>: Parser[Unit]

val >:: Parser[Unit]

val @: Parser[Unit]

val ExprLiteral: Parser[Unit]

val Id: Parser[Unit]

helper printing function

val Ids: Parser[Unit]

object KeyWordOperators

Most keywords don't just require the correct characters to match, they have to ensure that subsequent characters *don't* match in order for it to be a keyword.

object Literals

val Newline: Parser[Unit]

val NotNewline: P0

val OneNLMax: P0

val PatLiteral: Parser[Unit]

val PostDotCheck: Parser[Unit]

Sketchy way to whitelist a few suffixes that come after a .

val QualId: Parser[Unit]

val Semi: Parser[Unit]

val Semis: Parser[Unit]

val StableId: P0

val VarId: Parser[Unit]

val WL: Parser[Unit]

Parses whitespace, including newlines.

val WS: Parser[Unit]

Parses all whitespace, excluding newlines.

val XmlExpr: Parser[Unit]

val XmlPattern: Parser[Unit]

val _: Parser[Unit]

val _*: Parser[Unit]

val abstract: Parser[Unit]

final def asInstanceOf[T0]: T0

val case: Parser[Unit]

val catch: Parser[Unit]

val class: Parser[Unit]

def clone(): AnyRef

val def: Parser[Unit]

val do: Parser[Unit]

val else: Parser[Unit]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val extends: Parser[Unit]

val final: Parser[Unit]

def finalize(): Unit

val finally: Parser[Unit]

val for: Parser[Unit]

val forSome: Parser[Unit]

final def getClass(): Class[_]

def hashCode(): Int

val if: Parser[Unit]

val implicit: Parser[Unit]

val import: Parser[Unit]

final def isInstanceOf[T0]: Boolean

val lazy: Parser[Unit]

val macro: Parser[Unit]

val match: Parser[Unit]

final def ne(arg0: AnyRef): Boolean

val new: Parser[Unit]

final def notify(): Unit

final def notifyAll(): Unit

val object: Parser[Unit]

val override: Parser[Unit]

val package: Parser[Unit]

val private: Parser[Unit]

val protected: Parser[Unit]

val return: Parser[Unit]

val sealed: Parser[Unit]

val super: Parser[Unit]

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

val this: Parser[Unit]

val throw: Parser[Unit]

def toString(): String

val trait: Parser[Unit]

val try: Parser[Unit]

val type: Parser[Unit]

val val: Parser[Unit]

val var: Parser[Unit]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

val while: Parser[Unit]

val with: Parser[Unit]

val yield: Parser[Unit]

val {: Parser[Unit]

val }: Parser[Unit]