Exprs

abstract def BlockDef: R1

abstract def NewBody: R1

abstract def input: ParserInput

abstract val settings: Seq[String]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

def #: R1

final def ##(): Int

def %: R1

def %%: R1

def %/: R1

def %/%/: R1

def &: R1

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

def &&: R1

def +=: R1

def +~/~: R1

def ..: R1

def /: R1

def :: R1

def <%: R1

def <-: Rule[HNil, ::[String, HNil]]

def <:: R1

def <<: R1

def =: R1

def ==: R1

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def ==>: R1

def =>: Rule[HNil, ::[String, HNil]]

def >:: R1

def >>: R1

def @: R1

def ANY: Rule0

def AccessMod: R1

def ActorCall: R[subscript.ast.Ast.ActorCall]

def ActorCaseClause: R[subscript.ast.Ast.ActorCaseClause]

def ActorScriptCall: R[subscript.ast.Ast.ScriptCall]

def ActorShortClause: R[subscript.ast.Ast.ActorShortClause]

def Annot: R1

def AnnotType: R1

def Annotation: R[subscript.ast.Ast.Annotation]

def ArgList: R1

def Ascription: R1

object Basic

def Block: R1

def BlockExpr: R1

def BlockStats: R1

def Break: R[subscript.ast.Ast.SpecialConstant]

def CaretPrefixedScalaTerm: R[subscript.ast.Ast.Normal]

def Careted(r: () ⇒ R[subscript.ast.Ast.Node], parseCaret: Boolean = true): R[subscript.ast.Ast.Annotation]

def CaseClauseHeader: R1

def CaseClauses: R1

def Code(code: ⇒ Unit): Rule0

def CodeFragment: R[subscript.ast.Ast.Term]

def CodeFragmentMeta(symbolStart: String, symbolEnd: String): R1

def CodeFragmentRaw: R[subscript.ast.Ast.CodeFragment]

def CodeFragmentSimpleMeta[T <: subscript.ast.Ast.CodeFragment](symbol: String, generator: (String) ⇒ T): R[T]

def CompoundType: R1

def Concat: (S, S) ⇒ S

def Concat3: (S, S, S) ⇒ S

def Concat4: (S, S, S, S) ⇒ S

def Concat5: (S, S, S, S, S) ⇒ S

def Concat6: (S, S, S, S, S, S) ⇒ S

def Concat7: (S, S, S, S, S, S, S) ⇒ S

def ConcatSeq(delimiter: String): (Seq[String]) ⇒ String

def ConcatSeqComma: (Seq[String]) ⇒ String

def ConcatSeqDot: (Seq[String]) ⇒ String

def ConcatSeqNoDelim: (Seq[String]) ⇒ String

def ConcatSeqPipe: (Seq[String]) ⇒ String

def ConcatSeqSemi: (Seq[String]) ⇒ String

def ConcatSeqWith: (Seq[String]) ⇒ String

def Dataflow: R[subscript.ast.Ast.Dataflow]

def DataflowClause: R[subscript.ast.Ast.DataflowClause]

def DataflowClauseGen(head: String, isThenClause: Boolean): R[subscript.ast.Ast.DataflowClause]

def DataflowElseClause: R[subscript.ast.Ast.DataflowClause]

def DataflowExtraClause: R[subscript.ast.Ast.DataflowClause]

def DataflowMap: R[subscript.ast.Ast.DataflowMap]

def DataflowMapClause: R[subscript.ast.Ast.DataflowMapClause]

def DataflowMapClauseExtra: R[subscript.ast.Ast.DataflowMapClause]

def DataflowMapClauseGen(head: String): R[subscript.ast.Ast.DataflowMapClause]

def DataflowMapShort: R[subscript.ast.Ast.DataflowMapShort]

def DataflowThenClause: R[subscript.ast.Ast.DataflowClause]

def Dcl: R1

def Declaration: R[subscript.ast.Ast.Declaration]

def Delta: R[subscript.ast.Ast.SpecialConstant]

def DoubleCareted(r: () ⇒ R[subscript.ast.Ast.Node]): R[subscript.ast.Ast.Annotation]

def DoubleCaretedNumber(r: () ⇒ R[subscript.ast.Ast.Node]): R[subscript.ast.Ast.Annotation]

def EOI: Char

def Epsilon: R[subscript.ast.Ast.SpecialConstant]

def Eventhandling: R[subscript.ast.Ast.Eventhandling]

def EventhandlingLoop: R[subscript.ast.Ast.EventhandlingLoop]

def Expr1: R[subscript.ast.Ast.Expr1]

def Expr2: R[subscript.ast.Ast.Expr2]

def Expr3: R[subscript.ast.Ast.Expr3]

def Expr4: R[subscript.ast.Ast.Expr4]

def Expr5: R[subscript.ast.Ast.Expr5]

def Expr6: R[subscript.ast.Ast.Expr6]

def Expr7: R[subscript.ast.Ast.Expr7]

def Expr8: R[subscript.ast.Ast.Expr8]

def Expr9: R[subscript.ast.Ast.Expr9]

def Expr9Normal: R[subscript.ast.Ast.Expr9]

def Expr9Shorthand: R[subscript.ast.Ast.Expr9]

object ExprCtx extends WsCtx

def Exprs: R1

def ExtractOpt: (Option[String]) ⇒ String

def FunSig: R1

def Id: R1

object IdBank extends ScopeBank[String]

def IdS: R[String]

def IdentedNewLine(col: Int): R0

object Identifiers

def Ids: R1

def Import: R1

def IndentedNLSequence[T](r: () ⇒ R[T], minIndent: Int = Int.MaxValue): R[Seq[T]]

def InfixType: R1

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: R1

def Launch: R[subscript.ast.Ast.Launch]

def LaunchAnchor: R[subscript.ast.Ast.LaunchAnchor]

def Let: R[subscript.ast.Ast.Tiny]

def Literal: R1

object Literals

def LocalMod: R1

def Loop: R[subscript.ast.Ast.SpecialConstant]

def MATCH: Rule0

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

def MISMATCH0: Rule0

def Mod: R1

def Neutral: R[subscript.ast.Ast.SpecialConstant]

def Newline: R1

def Normal: R[subscript.ast.Ast.Normal]

def NotNewline: R1

def OneNLMax: R1

def OneOrMore(term: () ⇒ Rule1[String], delim: () ⇒ Rule1[String]): Rule1[String]

def OneOrMoreSeq[A, B](term: () ⇒ Rule1[A], delim: () ⇒ Rule1[B]): Rule1[(A, Seq[(B, A)])]

def OptionalBreak: R[subscript.ast.Ast.SpecialConstant]

def OptionalBreakLoop: R[subscript.ast.Ast.SpecialConstant]

def ParamType: R1

def Parenthesised: R[subscript.ast.Ast.Term]

def ParenthesisedCareted: R[subscript.ast.Ast.Annotation]

def ParenthesisedRaw: R[subscript.ast.Ast.Parenthesised]

def Pat: R1

def Pat1: R1

def Pat2: R1

def PatternWithGuard: R1

def Patterns: R1

def QualId: R1

def SSKeyword: Rule[HNil, ::[String, HNil]]

def SSOperator: Rule[HNil, ::[String, HNil]]

def SSOperatorOrKeyword: Rule[HNil, ::[String, HNil]]

def ScalaExprTerm: R[String]

def ScalaTerm: R[subscript.ast.Ast.Term]

def ScalaTermRaw: R1

def ScalaTupleTerm: R[String]

object ScopeSwitch extends Switch

def ScriptBody: R[subscript.ast.Ast.ScriptBody]

def ScriptCall: R[subscript.ast.Ast.Term]

def ScriptCallNice: R[subscript.ast.Ast.ScriptCall]

def ScriptCallOrdinary: R[subscript.ast.Ast.ScriptCall]

def ScriptCallRaw: R[subscript.ast.Ast.ScriptCall]

def ScriptDef: R[subscript.ast.Ast.ScriptDef]

def ScriptHeader: R[subscript.ast.Ast.ScriptHeader]

def ScriptTerm: R[subscript.ast.Ast.Literal]

def SecondStr: (S, S) ⇒ S

def Semi: R1

def SemiR0: R0

def Semis: R1

def SemisR0: R0

def SimplePat: R1

def SimpleType: R1

def SimpleValueExpr: R[subscript.ast.Ast.Literal]

def Spaces[T](r: () ⇒ R[T], ws: () ⇒ R0 = () => WSR0): R[T]

Consumes all the white spaces (ws) before the rule r silently.

def Special: R[subscript.ast.Ast.Term]

def SpecialConstant(symbol: String, counterpart: subscript.ast.Ast.SpecialConstant): R[subscript.ast.Ast.SpecialConstant]

def SpecialConstant(rle: () ⇒ R1, counterpart: subscript.ast.Ast.SpecialConstant): R[subscript.ast.Ast.SpecialConstant]

def StableId: R1

def StableIdS: R[String]

def StandardDecl[T <: subscript.ast.Ast.Declaration](keyword: () ⇒ Rule1[String], generator: (String, Option[String], subscript.ast.Ast.Node) ⇒ T): Rule[HNil, ::[T, HNil]]

object StatCtx extends WsCtx

def SubScriptCode: R1

def SubScriptCodeAst: R[subscript.ast.Ast.SubScriptCode]

def Term: R[subscript.ast.Ast.Term]

def TermRaw: R[subscript.ast.Ast.Term]

def Threaded: R[subscript.ast.Ast.Threaded]

def Tiny: R[subscript.ast.Ast.Tiny]

def Try[T](rle: () ⇒ Rule1[T], before: ⇒ Unit, after: ⇒ Unit = (), rollback: ⇒ Unit = ()): Rule1[T]

def Type: R1

def TypeArg: R1

def TypeArgList: R1

def TypeArgs: R1

def TypeBounds: R1

def TypeDcl: R1

def TypeDef: R1

def TypeExpr: R1

def TypePat: R1

def Types: R1

def Unsure: R[subscript.ast.Ast.Unsure]

def ValDcl: R1

def ValDecl: R[subscript.ast.Ast.ValDecl]

def ValueExpr: R[subscript.ast.Ast.Literal]

def VarCallCaretPrefix: R[subscript.ast.Ast.Normal]

def VarDecl: R[subscript.ast.Ast.VarDecl]

def VarId: R1

def WL: R1

def WLOneOrMoreR0: R0

def WLOneR0: R0

Parses whitespace, including newlines.

def WLR0: R0

def WS: R1

def WSOneOrMoreR0: R0

def WSOneR0: R0

Parses all whitespace, excluding newlines.

def WSR0: R0

def WhileLeaf: R[subscript.ast.Ast.While]

def WithAssignment[T](rle: () ⇒ Rule1[T]): Rule1[T]

def WithLaunch[T](rle: () ⇒ Rule1[T]): Rule1[T]

def WithLaunchAnchor[T](rle: () ⇒ Rule1[T]): Rule1[T]

def WithNiceScriptCall[T](rle: () ⇒ Rule1[T]): Rule1[T]

def WithNormal[T](rle: () ⇒ Rule1[T]): Rule1[T]

def WithNormalInScript[T](rle: () ⇒ Rule1[T]): Rule1[T]

def WithParentheses[T](rle: () ⇒ Rule1[T]): Rule1[T]

def WithPattern[T](rle: () ⇒ Rule1[T]): Rule1[T]

def WithScope[T](rle: () ⇒ Rule1[T], scope: Int): Rule1[T]

def WithScript[T](rle: () ⇒ Rule1[T]): Rule1[T]

def WrappedExpr9[T](start: String, end: String, generator: (subscript.ast.Ast.Expr9) ⇒ T): R[T]

def XmlExpr: R1

def XmlPattern: R1

def ZeroOrMore(term: () ⇒ Rule1[String], delim: () ⇒ Rule1[String]): Rule1[String]

def ZeroOrMoreSeq[A, B](term: () ⇒ Rule1[A], delim: () ⇒ Rule1[B]): Rule1[Option[(A, Seq[(B, A)])]]

def ^: R1

def _: R1

def _*: R1

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: R1

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: R1

def catch: R1

implicit def ch(c: Char): Rule0

def charAt(offset: Int): Char

def charAtRC(offset: Int): Char

def class: R1

def clone(): AnyRef

def col: Int

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

def cursor: Int

def cursorChar: Char

def def: R1

def do: R1

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

def else: R1

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def errorTraceCollectionLimit: Int

def extends: R1

def fail(expected: String): Rule0

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

def final: R1

def finalize(): Unit

def finally: R1

def for: R1

def forSome: R1

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

final def getClass(): Class[_]

def hashCode(): Int

def if: R1

def ignoreCase(s: String): Rule0

def ignoreCase(c: Char): Rule0

def implicit: R1

def import: R1

implicit def int2NTimes(i: Int): NTimes

final def isInstanceOf[T0]: Boolean

def lastChar: Char

def lazy: R1

def let: R1

def macro: R1

def match: R1

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

final def ne(arg0: AnyRef): Boolean

def new: R1

def noneOf(chars: String): Rule0

final def notify(): Unit

final def notifyAll(): Unit

def object: R1

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: R1

def package: R1

def plus: R1

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

helper printing function

implicit def predicate(p: CharPredicate): Rule0

def private: R1

def protected: R1

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: R1

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 script: R1

def sealed: R1

implicit def str(s: String): Rule0

implicit def str2CharRangeSupport(s: String): CharRangeSupport

def super: R1

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

def test(condition: Boolean): Rule0

def then: R1

def this: R1

def throw: R1

def toString(): String

def trait: R1

def try: R1

def type: R1

def val: R1

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

def valueStack: ValueStack

def var: R1

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def while: R1

def with: R1

def withR0: Rule0

def wspChR0(s: Char): R0

implicit def wspChR1(s: Char): R1

def wspStrR0(s: String): R0

implicit def wspStrR1(s: String): R1

def yield: R1

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

def {: R1

def |: R1

def ||: R1

def }: R1

def ~~: R1