Value Members

1.  final def !=(arg0: Any): Boolean

   Definition Classes

   Any

2.  final def ##(): Int

   Definition Classes

   Any

3.  final def ==(arg0: Any): Boolean

   Definition Classes

   Any

4.  final def asInstanceOf[T0]: T0

   Definition Classes

   Any

5.  def getClass(): Class[_ <: AnyVal]

   Definition Classes

   AnyVal → Any

6.  final def isInstanceOf[T0]: Boolean

   Definition Classes

   Any

7.  def opaque(msg: String)(implicit ctx: P[Any]): P[T]

   Hides the internals of the given parser when it fails, such that it only succeeds completely or fails completely, and none of it's internal parsers end up in the failure traces or failure stack to be displayed to the user.

8.  val parse0: () ⇒ P[T]
9.  macro def rep[V](min: Int)(implicit repeater: Repeater[T, V], whitespace: (P[_]) ⇒ P[Unit], ctx: P[Any]): P[V]

   Repeat operator; runs the LHS parser at least min times separated by the given whitespace (in implicit scope), and returns a Seq[T] of the parsed values.

   Repeat operator; runs the LHS parser at least min times separated by the given whitespace (in implicit scope), and returns a Seq[T] of the parsed values. On failure, backtracks to the starting index of the last run.

10.  def rep[V](min: Int, sep: ⇒ P[_])(implicit repeater: Repeater[T, V], whitespace: (P[_]) ⇒ P[Unit], ctx: P[Any]): P[V]

    Repeat operator; runs the LHS parser at least min times separated by the given whitespace (in implicit scope) and separator sep, and returns a Seq[T] of the parsed values.

    Repeat operator; runs the LHS parser at least min times separated by the given whitespace (in implicit scope) and separator sep, and returns a Seq[T] of the parsed values. On failure, backtracks to the starting index of the last run.

11.  def rep[V](min: Int = 0, sep: ⇒ P[_] = null, max: Int = Int.MaxValue, exactly: Int = -1)(implicit repeater: Repeater[T, V], whitespace: (P[_]) ⇒ P[Unit], ctx: P[Any]): P[V]

    Repeat operator; runs the LHS parser at least min to at most max times separated by the given whitespace (in implicit scope) and separator sep, and returns a Seq[T] of the parsed values.

    Repeat operator; runs the LHS parser at least min to at most max times separated by the given whitespace (in implicit scope) and separator sep, and returns a Seq[T] of the parsed values. On failure, backtracks to the starting index of the last run.

    The convenience parameter exactly is provided to set both min and max to the same value.

12.  macro def rep[V](implicit repeater: Repeater[T, V], whitespace: (P[_]) ⇒ P[Unit], ctx: P[Any]): P[V]

    Repeat operator; runs the LHS parser 0 or more times separated by the given whitespace (in implicit scope), and returns a Seq[T] of the parsed values.

    Repeat operator; runs the LHS parser 0 or more times separated by the given whitespace (in implicit scope), and returns a Seq[T] of the parsed values. On failure, backtracks to the starting index of the last run.

13.  macro def repX[V](min: Int)(implicit repeater: Repeater[T, V], ctx: P[Any]): P[V]

    Raw repeat operator; runs the LHS parser at least min times *without* any whitespace in between, and returns a Seq[T] of the parsed values.

    Raw repeat operator; runs the LHS parser at least min times *without* any whitespace in between, and returns a Seq[T] of the parsed values. On failure, backtracks to the starting index of the last run.

14.  def repX[V](min: Int, sep: ⇒ P[_])(implicit repeater: Repeater[T, V], ctx: P[Any]): P[V]

    Raw repeat operator; runs the LHS parser at least min times separated by the separator sep, *without* any whitespace in between, and returns a Seq[T] of the parsed values.

    Raw repeat operator; runs the LHS parser at least min times separated by the separator sep, *without* any whitespace in between, and returns a Seq[T] of the parsed values. On failure, backtracks to the starting index of the last run.

15.  def repX[V](min: Int = 0, sep: ⇒ P[_] = null, max: Int = Int.MaxValue, exactly: Int = -1)(implicit repeater: Repeater[T, V], ctx: P[Any]): P[V]

    Raw repeat operator; runs the LHS parser at least min to at most max times separated by the separator sep *without* any whitespace in between, and returns a Seq[T] of the parsed values.

    Raw repeat operator; runs the LHS parser at least min to at most max times separated by the separator sep *without* any whitespace in between, and returns a Seq[T] of the parsed values. On failure, backtracks to the starting index of the last run.

    The convenience parameter exactly is provided to set both min and max to the same value.

16.  macro def repX[V](implicit repeater: Repeater[T, V], ctx: P[Any]): P[V]

    Raw repeat operator; runs the LHS parser 0 or more times *without* any whitespace in between, and returns a Seq[T] of the parsed values.

    Raw repeat operator; runs the LHS parser 0 or more times *without* any whitespace in between, and returns a Seq[T] of the parsed values. On failure, backtracks to the starting index of the last run.

17.  def toString(): String

    Definition Classes

    Any

18.  def unary_!(implicit ctx: P[Any]): P[Unit]

    Negative lookahead operator: succeeds if the wrapped parser fails and fails if the wrapped parser succeeds.

    Negative lookahead operator: succeeds if the wrapped parser fails and fails if the wrapped parser succeeds. In all cases, it ends up consuming zero characters.