DisjunctiveParser

final def !=(arg0: Any): Boolean

final def ##(): Int

def *(sep: Parser[_]): Parser[List[A]]

def *(): Parser[List[A]]

def +(sep: Parser[_]): Parser[List[A]]

def +(): Parser[List[A]]

def +?: Parser[Option[List[A]]]

def ->[B](y: B): (DisjunctiveParser[A], B)

def <~[R2](that: Parser[R2]): Parser[A]

final def ==(arg0: Any): Boolean

def ?(): Parser[Option[A]]

def \(not: TerminalParser[Any]): Parser[A]

def ^^^[R2](v: ⇒ R2): Parser[R2]

def andThen[A](g: (Stream[Result[A]]) ⇒ A): (LineStream) ⇒ A

final def apply(in: LineStream): Stream[Result[A]]

This method takes care of kicking off a new parse process.

def apply(str: String): Stream[Result[A]]

final def asInstanceOf[T0]: T0

def chain(t: Trampoline, in: LineStream)(f: (Result[A]) ⇒ Unit): Unit

def clone(): AnyRef

def compose[A](g: (A) ⇒ LineStream): (A) ⇒ Stream[Result[A]]

def computeFirst(seen: Set[Parser[Any]]): Option[Set[Option[Char]]]

def ensuring(cond: (DisjunctiveParser[A]) ⇒ Boolean, msg: ⇒ Any): DisjunctiveParser[A]

def ensuring(cond: (DisjunctiveParser[A]) ⇒ Boolean): DisjunctiveParser[A]

def ensuring(cond: Boolean, msg: ⇒ Any): DisjunctiveParser[A]

def ensuring(cond: Boolean): DisjunctiveParser[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(f: (A) ⇒ Boolean): Parser[A]

def finalize(): Unit

lazy val first: Set[Char]

def flatMap[R2](f1: (A) ⇒ Parser[R2]): Parser[R2]

def formatted(fmtstr: String): String

lazy val gather: List[Parser[A]]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

lazy val isLL1: Boolean

Checks if all FIRST sets are disjoint and none are empty.

def isPreferred: Boolean

def map[R2](f: (A) ⇒ R2): Parser[R2]

def mapWithTail[R2](f1: (LineStream, A) ⇒ R2): Parser[R2]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def orElse[R2 >: A](alternate: ⇒ Parser[R2]): Parser[R2]

lazy val predict: Map[Char, Parser[A]]

The PREDICT table for this disjunction.

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

final val terminal: Boolean(false)

def thunk[A](field: Symbol): () ⇒ A

def toParArray: ParArray[T]

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def ~[R2](that: Parser[R2]): Parser[~[A, R2]]

def ~>[R2](that: Parser[R2]): Parser[R2]

def →[B](y: B): (DisjunctiveParser[A], B)

def +(other: String): String