Exprs

abstract def AnonTmpl: P0

abstract def BlockDef: P0

abstract def FunDef: P0

abstract def ValVarDef: 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]

val =: Parser[Unit]

final def ==(arg0: Any): Boolean

val =>: Parser[Unit]

val >:: Parser[Unit]

val @: Parser[Unit]

val AccessMod: P0

val Annot: P0

val AnnotType: Parser[Unit]

val ArgList: P0

val BindPattern: P0

val Block: P0

val BlockExpr: P0

val BlockLambda: Parser[Unit]

val BlockLambdaHead: P0

val BlockStat: Parser[Unit]

val CaseClauses: P0

val CompoundType: Parser[Unit]

val Dcl: P0

val ExistentialClause: Parser[Unit]

object ExprCtx extends WsCtx

val ExprLiteral: Parser[Unit]

val Exprs: P0

val FunSig: P0

val Id: Parser[Unit]

helper printing function

val Ids: Parser[Unit]

val Import: P0

val InfixType: 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 LocalMod: P0

val Mod: P0

val Newline: Parser[Unit]

val NotNewline: P0

val OneNLMax: P0

val ParenArgList: Parser[Unit]

val PatLiteral: Parser[Unit]

val Pattern: P0

val Patterns: P0

val PostDotCheck: Parser[Unit]

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

val PostfixType: Parser[Unit]

val QualId: Parser[Unit]

val Semi: Parser[Unit]

val Semis: Parser[Unit]

val SimplePattern: P0

val SimpleType: P0

val StableId: P0

object StatCtx extends WsCtx

val Type: P0

val TypeArg: P0

val TypeArgList: P0

val TypeArgs: Parser[Unit]

val TypeBounds: P0

val TypeDef: P0

val TypeExpr: P0

val TypeOrBindPattern: P0

val TypePat: Parser[Unit]

val TypePattern: Parser[Unit]

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]