RegexParsers

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def accept[U](expected: CharBuffer, f: PartialFunction[CharBuffer, U]): Parser[CharBuffer, U]

def accept[ES](es: ES)(implicit arg0: (ES) ⇒ List[CharBuffer]): Parser[CharBuffer, Seg[CharBuffer]]

implicit def accept(e: CharBuffer): Parser[CharBuffer, CharBuffer]

def acceptAny: Parser[CharBuffer, CharBuffer]

def acceptIf(p: (CharBuffer) ⇒ Boolean)(err: (CharBuffer) ⇒ String): Parser[CharBuffer, CharBuffer]

def acceptMatch[U](expected: CharBuffer, f: PartialFunction[CharBuffer, U]): Parser[CharBuffer, U]

def acceptSeq[ES](es: ES)(implicit arg0: (ES) ⇒ Iterable[CharBuffer]): Parser[CharBuffer, Seg[CharBuffer]]

def acceptSignal(signal: Signal): Parser[CharBuffer, Nothing]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def elem(e: CharBuffer): Parser[CharBuffer, CharBuffer]

def elem(kind: String, p: (CharBuffer) ⇒ Boolean): Parser[CharBuffer, CharBuffer]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fail(msg: ⇒ String): Parser[CharBuffer, Nothing]

def finalize(): Unit

final def getClass(): Class[_]

def handleWhiteSpace(source: Seg[CharBuffer]): Seg[CharBuffer]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

implicit def literal(s: String): Parser[CharBuffer, String]

A parser that matches a literal string

def log[T](p: ⇒ Parser[CharBuffer, T])(name: String): Parser[CharBuffer, T]

def mkList[T]: (~[T, List[T]]) ⇒ List[T]

def mkSeg[T]: (~[T, Seg[T]]) ⇒ seg.Seg[T]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def opt[T](p: ⇒ Parser[CharBuffer, T]): Parser[CharBuffer, Option[T]]

implicit def parsers: Parsers[CharBuffer]

implicit def regex(r: Regex): Parser[CharBuffer, String]

A parser that matches a regex string

def rep[T](p: ⇒ Parser[CharBuffer, T]): Parser[CharBuffer, Seg[T]]

def rep1[T](first: ⇒ Parser[CharBuffer, T], next: ⇒ Parser[CharBuffer, T]): Parser[CharBuffer, Seg[T]]

def rep1[T](p: ⇒ Parser[CharBuffer, T]): Parser[CharBuffer, Seg[T]]

def rep1sep[T](p: ⇒ Parser[CharBuffer, T], q: ⇒ Parser[CharBuffer, Any]): Parser[CharBuffer, Seg[T]]

def repN[T](num: Int, p: ⇒ Parser[CharBuffer, T]): Parser[CharBuffer, Seg[T]]

def repsep[T](p: ⇒ Parser[CharBuffer, T], q: ⇒ Parser[CharBuffer, Any]): Parser[CharBuffer, Seg[T]]

def skipWhitespace: Boolean

def success[T](v: T): Parser[CharBuffer, T] { ... /* 2 definitions in type refinement */ }

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

val whiteSpace: Regex

def err(msg: ⇒ String): Parser[CharBuffer, CharBuffer]