sealed class Rule[-I <: HList, +O <: HList] extends RuleX
The general model of a parser rule.
It is characterized by consuming a certain number of elements from the value stack (whose types are captured by the
HList type parameter I
for "Input") and itself pushing a certain number of elements onto the value stack (whose
types are captured by the HList type parameter O
for "Output").
At runtime there are only two instances of this class which signal whether the rule has matched (or mismatched) at the current point in the input.
- Source
- Rule.scala
- Alphabetic
- By Inheritance
- Rule
- RuleX
- AnyRef
- Any
- by Runnable
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- All
Instance Constructors
- new Rule()
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
def
*(separator: Rule0)(implicit l: Lifter[Seq, I, O]): Rule[In, OptionalOut]
Postfix shortcut for
zeroOrMore(...).separatedBy(...)
.Postfix shortcut for
zeroOrMore(...).separatedBy(...)
.- Annotations
- @compileTimeOnly( ... )
-
def
*(implicit l: Lifter[Seq, I, O]): Rule[In, OptionalOut] with Repeated
Postfix shortcut for
zeroOrMore
.Postfix shortcut for
zeroOrMore
.- Annotations
- @compileTimeOnly( ... )
-
def
+(separator: Rule0)(implicit l: Lifter[Seq, I, O]): Rule[In, StrictOut]
Postfix shortcut for
oneOrMore(...).separatedBy(...)
.Postfix shortcut for
oneOrMore(...).separatedBy(...)
.- Annotations
- @compileTimeOnly( ... )
-
def
+(implicit l: Lifter[Seq, I, O]): Rule[In, StrictOut] with Repeated
Postfix shortcut for
oneOrMore
.Postfix shortcut for
oneOrMore
.- Annotations
- @compileTimeOnly( ... )
- def ->[B](y: B): (Rule[I, O], B)
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
?(implicit l: Lifter[Option, I, O]): Rule[In, OptionalOut]
Postfix shortcut for
optional
.Postfix shortcut for
optional
.- Annotations
- @compileTimeOnly( ... )
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
- def ensuring(cond: (Rule[I, O]) ⇒ Boolean, msg: ⇒ Any): Rule[I, O]
- def ensuring(cond: (Rule[I, O]) ⇒ Boolean): Rule[I, O]
- def ensuring(cond: Boolean, msg: ⇒ Any): Rule[I, O]
- def ensuring(cond: Boolean): Rule[I, O]
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
- def formatted(fmtstr: String): String
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
named(name: String): Rule.this.type
Attaches the given explicit name to this rule.
Attaches the given explicit name to this rule.
- Annotations
- @compileTimeOnly( ... )
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
macro
def
run()(implicit scheme: DeliveryScheme[O]): Result
- Implicit
- This member is added by an implicit conversion from Rule[I, O] to Runnable[O] performed by method Runnable in akka.parboiled2.Rule. This conversion will take place only if I is a superclass of HNil (I >: HNil) and at the same time O is a subclass of HList (O <: HList).
- Definition Classes
- Runnable
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
unary_!(): Rule0
Creates a "negative syntactic predicate", i.e.
Creates a "negative syntactic predicate", i.e. a rule that matches only if this rule mismatches and vice versa. The resulting rule doesn't cause the parser to make any progress (i.e. match any input) and also clears out all effects that the underlying rule might have had on the value stack.
- Annotations
- @compileTimeOnly( ... )
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
|[I2 <: I, O2 >: O <: HList](that: Rule[I2, O2]): Rule[I2, O2]
Combines this rule with the given other one in a way that the resulting rule matches if this rule matches or the other one matches.
Combines this rule with the given other one in a way that the resulting rule matches if this rule matches or the other one matches. If this rule doesn't match the parser is reset and the given alternative tried. This operators therefore implements the "ordered choice' PEG combinator.
- Annotations
- @compileTimeOnly( ... )
-
def
~[I2 <: HList, O2 <: HList](that: Rule[I2, O2])(implicit i: TailSwitch[I2, O, I], o: TailSwitch[O, I2, O2]): Rule[Out, Out]
Concatenates this rule with the given other one.
Concatenates this rule with the given other one. The resulting rule type is computed on a type-level. Here is an illustration (using an abbreviated HList notation): Rule[, A] ~ Rule[, B] = Rule[, A:B] Rule[A:B:C, D:E:F] ~ Rule[F, G:H] = Rule[A:B:C, D:E:G:H] Rule[A, B:C] ~ Rule[D:B:C, E:F] = Rule[D:A, E:F]
- Annotations
- @compileTimeOnly( ... )
-
def
~!~[I2 <: HList, O2 <: HList](that: Rule[I2, O2])(implicit i: TailSwitch[I2, O, I], o: TailSwitch[O, I2, O2]): Rule[Out, Out]
Same as
~
but with "cut" semantics, meaning that the parser will never backtrack across this boundary.Same as
~
but with "cut" semantics, meaning that the parser will never backtrack across this boundary. If the rule being concatenated doesn't match a parse error will be triggered immediately.- Annotations
- @compileTimeOnly( ... )
- def →[B](y: B): (Rule[I, O], B)
Shadowed Implicit Value Members
-
def
+(other: String): String
- Implicit
- This member is added by an implicit conversion from Rule[I, O] to any2stringadd[Rule[I, O]] performed by method any2stringadd in scala.Predef.
- Shadowing
- This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:(rule: any2stringadd[Rule[I, O]]).+(other)
- Definition Classes
- any2stringadd