RegexParser

final def !=(arg0: Any): Boolean

final def ##(): Int

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

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

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

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

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

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

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

final def ==(arg0: Any): Boolean

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

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

def ^^^[R2](v: ⇒ R2): RegexParsers.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: RegexParsers.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[RegexParsers.Parser[Any]]): Some[Set[Option[Char]]]

lazy val constFirst: Some[Set[Option[Char]]]

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

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

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

def ensuring(cond: Boolean): RegexParser

final def eq(arg0: AnyRef): Boolean

def equals(other: Any): Boolean

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

def finalize(): Unit

lazy val first: Set[Char]

def flatMap[R2](f1: (String) ⇒ RegexParsers.Parser[R2]): RegexParsers.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): RegexParsers.Parser[R2]

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def parse(in: LineStream): Product with Serializable with Result[String]

def preferred: RegexParsers.TerminalParser[String]

val regex: Regex

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

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

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

def +(other: String): String