ParserOps

abstract val self: Parser[A]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def -|[B](f: (A) ⇒ B): Parser[B]

a -| f is shorthand for a map f

def <~[B](n: ⇒ Parser[B]): Parser[A]

a <~ b is shorthand for discardRight(a, b)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def >|[B](b: ⇒ B): Parser[B]

a >| b is shorthand for a map (_ => b)

final def asInstanceOf[T0]: T0

def attempt: Parser[A]

def clone(): AnyRef

def collect[B](pf: PartialFunction[A, B]): Parser[B]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def many: Parser[List[A]]

def many1: Parser[NonEmptyList[A]]

def manyN(n: Int): Parser[List[A]]

def named(s: ⇒ String): Parser[A]

def namedOpaque(s: ⇒ String): Parser[A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def parens: Parser[A]

def parse(b: String): ParseResult[A]

def parseOnly(b: String): ParseResult[A]

def sepBy[B](s: Parser[B]): Parser[List[A]]

def sepBy1[B](s: Parser[B]): Parser[NonEmptyList[A]]

def skipMany: Parser[Unit]

def skipMany1: Parser[Unit]

def skipManyN(n: Int): Parser[Unit]

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

def toString(): String

def token: Parser[A]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def |[B >: A](n: ⇒ Parser[B]): Parser[B]

a | b is shorthand for orElse(a, b)

def ||[B](n: ⇒ Parser[B]): Parser[Either[A, B]]

a || b is shorthand for either(a, b)

def ~[B](n: ⇒ Parser[B]): Parser[(A, B)]

a ~ b is shorthand for andThen(a, b)

def ~>[B](n: ⇒ Parser[B]): Parser[B]

a ~> b is shorthand for discardLeft(a, b)