ElementCombinatorBase

abstract def parser: Parser

Parser - a Gram can provide a parser, which...

abstract def unparser: Unparser

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def LV[T](sym: Symbol)(body: ⇒ T): OOLAGValue[T]

final def SDE(str: String, args: Any*): Nothing

final def SDW(warnID: WarnID, str: String, args: Any*): Unit

final def areLogging(lvl: Type): Boolean

final def asInstanceOf[T0]: T0

final def assuming(pred: Boolean): Unit

final def checkErrors: Unit

def clone(): AnyRef

final val context: SchemaComponent

final var currentOVList: Seq[OOLAGValueBase]

lazy val diagnosticDebugName: String

def diagnostics: Seq[Diagnostic]

def doLogging(lvl: Type, msg: String, args: Seq[Any]): Unit

lazy val eAfterParser: Maybe[Parser]

lazy val eAfterUnparser: Maybe[Unparser]

lazy val eBeforeParser: Maybe[Parser]

lazy val eBeforeUnparser: Maybe[Unparser]

lazy val eParser: Maybe[Parser]

lazy val eUnparser: Maybe[Unparser]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error(th: Diagnostic): Unit

final def errors: Seq[Diagnostic]

def finalize(): Unit

val forWhat: ParserOrUnparser

final def getClass(): Class[_]

def getDiagnostics: Seq[Diagnostic]

def getLogWriter(): LogWriter

final def getLoggingLevel(): Type

final def hasNoParser: Parser

final def hasNoUnparser: Unparser

final def hasOOLAGRootSetup: Boolean

def hashCode(): Int

def isEmpty: Boolean

def isError: Boolean

final def isInstanceOf[T0]: Boolean

final macro def log(lvl: Type, msg: String, args: Any*): Unit

lazy val logID: String

var logLevel: Maybe[Type]

var logWriter: Maybe[LogWriter]

final val nArgs: Args

def name: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final lazy val oolagContext: OOLAGHost

final def oolagContextViaArgs: Some[OOLAGHost]

def oolagError(th: Diagnostic): Unit

final def oolagParent: OOLAGHost

def oolagWarn(th: Diagnostic): Unit

lazy val pSetVar: Array[Parser]

lazy val patAssert: Array[Parser]

lazy val patDiscrim: Maybe[Parser]

lazy val path: String

final def requiredEvaluations(lv: OOLAGValueBase): Unit

final def requiredEvaluations(arg: ⇒ Any): Unit

def setLogWriter(lw: LogWriter): Unit

def setLoggingLevel(level: Type): Unit

final def setOOLAGContext(oolagContextArg: OOLAGHost): Unit

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

lazy val testAssert: Array[Parser]

lazy val testDiscrim: Maybe[Parser]

def toString(): String

lazy val uSetVar: Array[Unparser]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def warn(th: Diagnostic): Unit

final def warnings: Seq[Diagnostic]

macro def withLoggingLevel[S](newLevel: Type)(body: ⇒ S): Unit

def |(qq: ⇒ Gram): Gram

def ||(qq: ⇒ Gram): Gram

This || operator means one of the operands ONLY.

def ~(qq: ⇒ Gram): Gram

Sequential composition operator in the grammar.