LiteralParser

final def !=(arg0: Any): Boolean

final def ##(): Int

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

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

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

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

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

def ->[B](y: B): (LiteralParser, B)

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

final def ==(arg0: Any): Boolean

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

def \(not: TerminalParser[Any]): TerminalParser[String]

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

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

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

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

final def asInstanceOf[T0]: T0

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

For terminal parsing, this just delegates back to apply()

def clone(): AnyRef

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

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

def ensuring(cond: (LiteralParser) ⇒ Boolean, msg: ⇒ Any): LiteralParser

def ensuring(cond: (LiteralParser) ⇒ Boolean): LiteralParser

def ensuring(cond: Boolean, msg: ⇒ Any): LiteralParser

def ensuring(cond: Boolean): LiteralParser

final def eq(arg0: AnyRef): Boolean

def equals(other: Any): Boolean

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

def finalize(): Unit

lazy val first: Set[Char]

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

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def isPreferred: Boolean

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

def mapWithTail[R2](f: (LineStream, String) ⇒ R2): Parser[R2]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def parse(in: LineStream): Result[String]

def preferred: TerminalParser[String]

val str: String

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

final val terminal: Boolean(true)

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](other: Parser[R2]): Parser[~[String, R2]]

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

def →[B](y: B): (LiteralParser, B)

def +(other: String): String