Value Members

1.  def &(sub: Rule): Rule0

   Creates an "AND" syntactic predicate according to the PEG formalism.

2.  lazy val ANY: Rule0

   A rule that matches any single character except EOI.

3.  val BasicParseRunner: scala.parserunners.BasicParseRunner.type
4.  lazy val DEDENT: Rule0

   A rule that matches the "DEDENT" non-character as produced by the IndentDedentInputBuffer.

5.  lazy val DROP: PopRule1[Any]

   A parser action removing the top element from the value stack.

6.  lazy val DROP2: PopRule2[Any, Any]

   A parser action removing the top two elements from the value stack.

7.  lazy val DROP3: PopRule3[Any, Any, Any]

   A parser action removing the top three elements from the value stack.

8.  lazy val EMPTY: Rule0

   A rule that always matches but consumes no input.

9.  lazy val EOI: Rule0

   A rule that matches the End-Of-Input non-character.

10.  lazy val INDENT: Rule0

    A rule that matches the "INDENT" non-character as produced by the IndentDedentInputBuffer.

11.  lazy val NOTHING: Rule0

    A rule that never matches anything (i.e.

    A rule that never matches anything (i.e. that always fails).

12.  val RecoveringParseRunner: scala.parserunners.RecoveringParseRunner.type
13.  val ReportingParseRunner: scala.parserunners.ReportingParseRunner.type
14.  val TracingParseRunner: scala.parserunners.TracingParseRunner.type
15.  implicit def charArray2Input(input: Array[Char]): Input
16.  implicit def creator4PopRule1[Z](m: Matcher): PopRule1[Z]
17.  implicit def creator4PopRule2[Y, Z](m: Matcher): PopRule2[Y, Z]
18.  implicit def creator4PopRule3[X, Y, Z](m: Matcher): PopRule3[X, Y, Z]
19.  implicit def creator4ReductionRule1[Z, R](m: Matcher): ReductionRule1[Z, R]
20.  implicit def creator4ReductionRule2[Y, Z, R](m: Matcher): ReductionRule2[Y, Z, R]
21.  implicit def creator4ReductionRule3[X, Y, Z, R](m: Matcher): ReductionRule3[X, Y, Z, R]
22.  implicit def creator4Rule0(m: Matcher): Rule0
23.  implicit def creator4Rule1[A](m: Matcher): Rule1[A]
24.  implicit def creator4Rule2[A, B](m: Matcher): Rule2[A, B]
25.  implicit def creator4Rule3[A, B, C](m: Matcher): Rule3[A, B, C]
26.  implicit def creator4Rule4[A, B, C, D](m: Matcher): Rule4[A, B, C, D]
27.  implicit def creator4Rule5[A, B, C, D, E](m: Matcher): Rule5[A, B, C, D, E]
28.  implicit def creator4Rule6[A, B, C, D, E, F](m: Matcher): Rule6[A, B, C, D, E, F]
29.  implicit def creator4Rule7[A, B, C, D, E, F, G](m: Matcher): Rule7[A, B, C, D, E, F, G]
30.  def group[T <: Rule](rule: T): T

    Groups the given sub rule into one entity so that a following ~> operator receives the text matched by the whole group rather than only the immediately preceding sub rule.

31.  implicit def inputStream2Input(input: InputStream)(implicit codec: Codec): Input
32.  def make[A, U](a: A)(f: (A) ⇒ U): A
33.  implicit def source2Input(input: Source): Input
34.  implicit def string2Input(input: String): Input
35.  implicit def toRunAction(f: (Context[Any]) ⇒ Unit): Rule0
36.  implicit def toTestAction(f: (Context[Any]) ⇒ Boolean): Rule0
37.  object MemoMismatches extends RuleOption with Product with Serializable

    Enables memoization of rule mismatches for consecutive rule applications at the same input location.

38.  object ParsingResult
39.  object SkipNode extends RuleOption with Product with Serializable

    This rule option advises parboiled to not create a parse tree node for this rule (in case that parse tree building is enabled on the parser).

40.  object SuppressNode extends RuleOption with Product with Serializable

    This rule option advises parboiled to not create a parse tree node for this rule and all sub rules (in case that parse tree building is enabled on the parser).

41.  object SuppressSubnodes extends RuleOption with Product with Serializable

    This rule option advises parboiled to not create a parse tree node for the sub rules of this rule (in case that parse tree building is enabled on the parser).