Exprs

abstract def BlockDef: R0

abstract def DefDef: R0

abstract def NewBody: R0

abstract def ValDef: R0

abstract def VarDef: R0

abstract def input: ParserInput

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

def #: Rule[HNil, HNil]

final def ##(): Int

def &(r: Rule[_, _]): Rule0

def :: Rule[HNil, HNil]

def <%: Rule[HNil, HNil]

def <-: Rule[HNil, HNil]

def <:: Rule[HNil, HNil]

def =: Rule[HNil, HNil]

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def =>: Rule[HNil, HNil]

def >:: Rule[HNil, HNil]

def @: Rule[HNil, HNil]

def ANY: Rule0

def AccessMod: R0

def Annot: R0

def AnnotType: Rule[HNil, HNil]

def ArgList: R0

def Ascription: Rule[HNil, HNil]

object Basic

def Block: R0

def BlockExpr: R0

def BlockStats: R0

def CaseClauses: R0

def CompoundType: Rule[HNil, HNil]

def Dcl: R0

def EOI: Char

object ExprCtx extends WsCtx

def Exprs: R0

def FunSig: R0

def Id: Rule[HNil, HNil]

object Identifiers

def Ids: Rule[HNil, HNil]

def Import: R0

def InfixType: Rule[HNil, HNil]

object Key

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 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.

def LambdaHead: R0

def Literal: Rule[HNil, HNil]

object Literals

def LocalMod: R0

def MATCH: Rule0

def MISMATCH[I <: HList, O <: HList]: Rule[I, O]

def MISMATCH0: Rule0

def Mod: R0

def Newline: Rule[HNil, HNil]

def NotNewline: R0

def OneNLMax: R0

def ParamType: Rule[HNil, HNil]

def Pat: R0

def Pat1: R0

def Pat2: R0

def Patterns: R0

def QualId: Rule[HNil, HNil]

def Semi: Rule[HNil, HNil]

def Semis: Rule[HNil, HNil]

def SimplePat: R0

def SimpleType: R0

def StableId: R0

object StatCtx extends WsCtx

def Type: R0

def TypeArg: R0

def TypeArgList: R0

def TypeArgs: Rule[HNil, HNil]

def TypeBounds: R0

def TypeDcl: R0

def TypeDef: R0

def TypeExpr: R0

def TypePat: Rule[HNil, HNil]

def Types: Rule[HNil, HNil]

def VarId: Rule[HNil, HNil]

def WL: Rule[HNil, HNil]

Parses whitespace, including newlines.

def WS: Rule[HNil, HNil]

Parses all whitespace, excluding newlines.

def XmlExpr: Rule[HNil, HNil]

def XmlPattern: Rule[HNil, HNil]

def _: Rule[HNil, HNil]

def _*: Rule[HNil, HNil]

def __advance(): Boolean

def __bubbleUp(prefix: List[NonTerminal], terminal: Terminal): Nothing

def __bubbleUp(terminal: Terminal): Nothing

def __enterAtomic(start: Int): Boolean

def __enterNotPredicate(): AnyRef

def __enterQuiet(): Int

def __exitAtomic(saved: Boolean): Unit

def __exitNotPredicate(saved: AnyRef): Unit

def __exitQuiet(saved: Int): Unit

def __hardFail(expected: String): Nothing

def __inErrorAnalysis: Boolean

final def __matchAnyOf(string: String, ix: Int): Boolean

final def __matchIgnoreCaseString(string: String, ix: Int): Boolean

final def __matchIgnoreCaseStringWrapped(string: String, ix: Int): Boolean

def __matchMap(m: Map[String, Any]): Boolean

def __matchMapWrapped(m: Map[String, Any]): Boolean

final def __matchNoneOf(string: String, ix: Int): Boolean

final def __matchString(string: String, ix: Int): Boolean

final def __matchStringWrapped(string: String, ix: Int): Boolean

def __push(value: Any): Boolean

def __registerMismatch(): Boolean

def __restoreState(mark: Mark): Unit

def __run[L <: HList](rule: ⇒ RuleN[L])(implicit scheme: DeliveryScheme[L]): Result

def __saveState: Mark

def __updateMaxCursor(): Boolean

def abstract: Rule[HNil, HNil]

def anyOf(chars: String): Rule0

final def asInstanceOf[T0]: T0

def atomic[I <: HList, O <: HList](r: Rule[I, O]): Rule[I, O]

def capture[I <: HList, O <: HList](r: Rule[I, O])(implicit p: Prepend[O, ::[String, HNil]]): Rule[I, Out]

def case: Rule[HNil, HNil]

def catch: Rule[HNil, HNil]

implicit def ch(c: Char): Rule0

def charAt(offset: Int): Char

def charAtRC(offset: Int): Char

def class: Rule[HNil, HNil]

def clone(): AnyRef

def copyStateFrom(other: Parser, offset: Int): Unit

def cursor: Int

def cursorChar: Char

def def: Rule[HNil, HNil]

def do: Rule[HNil, HNil]

def drop[T](implicit h: HListable[T]): PopRule[Out]

def else: Rule[HNil, HNil]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def errorTraceCollectionLimit: Int

def extends: Rule[HNil, HNil]

def fail(expected: String): Rule0

def failX[I <: HList, O <: HList](expected: String): Rule[I, O]

def final: Rule[HNil, HNil]

def finalize(): Unit

def finally: Rule[HNil, HNil]

def for: Rule[HNil, HNil]

def forSome: Rule[HNil, HNil]

def formatError(error: ParseError, formatter: ErrorFormatter): String

final def getClass(): Class[_]

def hashCode(): Int

def if: Rule[HNil, HNil]

def ignoreCase(s: String): Rule0

def ignoreCase(c: Char): Rule0

def implicit: Rule[HNil, HNil]

def import: Rule[HNil, HNil]

implicit def int2NTimes(i: Int): NTimes

final def isInstanceOf[T0]: Boolean

def lastChar: Char

def lazy: Rule[HNil, HNil]

def macro: Rule[HNil, HNil]

def match: Rule[HNil, HNil]

def namedRule[I <: HList, O <: HList](name: String)(r: Rule[I, O]): Rule[I, O]

final def ne(arg0: AnyRef): Boolean

def new: Rule[HNil, HNil]

def noneOf(chars: String): Rule0

final def notify(): Unit

final def notifyAll(): Unit

def object: Rule[HNil, HNil]

def oneOrMore[I <: HList, O <: HList](r: Rule[I, O])(implicit l: Lifter[Seq, I, O]): Rule[In, StrictOut] with Repeated

def optional[I <: HList, O <: HList](r: Rule[I, O])(implicit l: Lifter[Option, I, O]): Rule[In, OptionalOut]

def override: Rule[HNil, HNil]

def package: Rule[HNil, HNil]

def pr(s: String): Rule[HNil, HNil]

helper printing function

implicit def predicate(p: CharPredicate): Rule0

def private: Rule[HNil, HNil]

def protected: Rule[HNil, HNil]

def push[T](value: T)(implicit h: HListable[T]): RuleN[Out]

def quiet[I <: HList, O <: HList](r: Rule[I, O]): Rule[I, O]

implicit def range2NTimes(range: Range): NTimes

def return: Rule[HNil, HNil]

def rule[I <: HList, O <: HList](r: Rule[I, O]): Rule[I, O]

implicit def rule2ActionOperator[I <: HList, O <: HList](r: Rule[I, O])(implicit ops: ActionOps[I, O]): ActionOperator[I, O, Out]

implicit def rule2WithSeparatedBy[I <: HList, O <: HList](r: Rule[I, O] with Repeated): WithSeparatedBy[I, O]

def run[T](arg: T)(implicit rr: RunResult[T]): Out

def runSubParser[I <: HList, O <: HList](f: (ParserInput) ⇒ Rule[I, O]): Rule[I, O]

def sealed: Rule[HNil, HNil]

implicit def str(s: String): Rule0

implicit def str2CharRangeSupport(s: String): CharRangeSupport

def super: Rule[HNil, HNil]

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

def test(condition: Boolean): Rule0

def this: Rule[HNil, HNil]

def throw: Rule[HNil, HNil]

def toString(): String

def trait: Rule[HNil, HNil]

def try: Rule[HNil, HNil]

def type: Rule[HNil, HNil]

def val: Rule[HNil, HNil]

implicit def valueMap[T](m: Map[String, T])(implicit h: HListable[T]): RuleN[Out]

def valueStack: ValueStack

def var: Rule[HNil, HNil]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def while: Rule[HNil, HNil]

def with: Rule[HNil, HNil]

def yield: Rule[HNil, HNil]

def zeroOrMore[I <: HList, O <: HList](r: Rule[I, O])(implicit l: Lifter[Seq, I, O]): Rule[In, OptionalOut] with Repeated

def {: Rule[HNil, HNil]

def }: Rule[HNil, HNil]