CharRule

Instance Constructors

new CharRule(c: Char)

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def -(upperBound: String): Rule0

Creates a rule matching the range of characters between the character of this rule and the given character (inclusively).
Creates a rule matching the range of characters between the character of this rule and the given character (inclusively).

Definition Classes
CharRule → Rule0
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def append(other: Matcher): Matcher

Attributes
protected
Definition Classes
Rule
def append(other: Rule): Matcher

Attributes
protected
Definition Classes
Rule
def append(f: (Context[Any]) ⇒ Boolean): Matcher

Attributes
protected
Definition Classes
Rule
def append(action: Action[_]): Matcher

Attributes
protected
Definition Classes
Rule
def appendChoice(other: Matcher): Matcher

Attributes
protected
Definition Classes
Rule
def appendChoice(other: Rule): Matcher

Attributes
protected
Definition Classes
Rule
final def asInstanceOf[T0]: T0

Definition Classes
Any
val c: Char
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def label(label: String): CharRule.this.type

Definition Classes
Rule
val matcher: Matcher

Definition Classes
Rule0 → Rule
def memoMismatches: CharRule.this.type

Definition Classes
Rule
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def skipNode: CharRule.this.type

Definition Classes
Rule
def suppressNode: CharRule.this.type

Definition Classes
Rule
def suppressSubnodes: CharRule.this.type

Definition Classes
Rule
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
Rule → AnyRef → Any
def unary_!: Rule0

Creates a "NOT" syntactic predicate according to the PEG formalism.
Creates a "NOT" syntactic predicate according to the PEG formalism.

Definition Classes
Rule
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( ... )
def withMatcher(matcher: Matcher): CharRule.this.type

Attributes
protected
Definition Classes
Rule0 → Rule
def |(other: Rule0): Rule0

Definition Classes
Rule0
def ~[A, B, C, D, E, F, G](other: Rule7[A, B, C, D, E, F, G]): Rule7[A, B, C, D, E, F, G]

Definition Classes
Rule0
def ~[A, B, C, D, E, F](other: Rule6[A, B, C, D, E, F]): Rule6[A, B, C, D, E, F]

Definition Classes
Rule0
def ~[A, B, C, D, E](other: Rule5[A, B, C, D, E]): Rule5[A, B, C, D, E]

Definition Classes
Rule0
def ~[A, B, C, D](other: Rule4[A, B, C, D]): Rule4[A, B, C, D]

Definition Classes
Rule0
def ~[A, B, C](other: Rule3[A, B, C]): Rule3[A, B, C]

Definition Classes
Rule0
def ~[A, B](other: Rule2[A, B]): Rule2[A, B]

Definition Classes
Rule0
def ~[A](other: Rule1[A]): Rule1[A]

Definition Classes
Rule0
def ~[Z, R](other: ReductionRule1[Z, R]): ReductionRule1[Z, R]

Definition Classes
Rule0
def ~[Y, Z, R](other: ReductionRule2[Y, Z, R]): ReductionRule2[Y, Z, R]

Definition Classes
Rule0
def ~[X, Y, Z, R](other: ReductionRule3[X, Y, Z, R]): ReductionRule3[X, Y, Z, R]

Definition Classes
Rule0
def ~[Z](other: PopRule1[Z]): PopRule1[Z]

Definition Classes
Rule0
def ~[Y, Z](other: PopRule2[Y, Z]): PopRule2[Y, Z]

Definition Classes
Rule0
def ~[X, Y, Z](other: PopRule3[X, Y, Z]): PopRule3[X, Y, Z]

Definition Classes
Rule0
def ~(other: Rule0): CharRule.this.type

Connects two rules into a rule a sequence.
Connects two rules into a rule a sequence.

Definition Classes
Rule
def ~%(f: (String) ⇒ Unit): CharRule.this.type

Creates a simple parser action with the input text matched by the immediately preceding rule as parameter.
Creates a simple parser action with the input text matched by the immediately preceding rule as parameter.

Definition Classes
Rule
def ~:%(f: (Char) ⇒ Unit): CharRule.this.type

Creates a simple parser action with the first char of the input text matched by the immediately preceding rule as parameter.
Creates a simple parser action with the first char of the input text matched by the immediately preceding rule as parameter.

Definition Classes
Rule
def ~:>[R](f: (Char) ⇒ R): Rule1[R]

Definition Classes
Rule0
def ~:?(f: (Char) ⇒ Boolean): CharRule.this.type

Creates a semantic predicate on the first char of the input text matched by the immediately preceding rule.
Creates a semantic predicate on the first char of the input text matched by the immediately preceding rule.

Definition Classes
Rule
def ~>[R](f: (String) ⇒ R): Rule1[R]

Definition Classes
Rule0
def ~>>[R](f: (IndexRange) ⇒ R): Rule1[R]

Definition Classes
Rule0
def ~?(f: (String) ⇒ Boolean): CharRule.this.type

Creates a semantic predicate on the input text matched by the immediately preceding rule.
Creates a semantic predicate on the input text matched by the immediately preceding rule.

Definition Classes
Rule
def ~~%[X, Y, Z](f: (X, Y, Z) ⇒ Unit): PopRule3[X, Y, Z]

Definition Classes
Rule0
def ~~%[Y, Z](f: (Y, Z) ⇒ Unit): PopRule2[Y, Z]

Definition Classes
Rule0
def ~~%[Z](f: (Z) ⇒ Unit): PopRule1[Z]

Definition Classes
Rule0
def ~~>[X, Y, Z, R](f: (X, Y, Z) ⇒ R): ReductionRule3[X, Y, Z, R]

Definition Classes
Rule0
def ~~>[Y, Z, R](f: (Y, Z) ⇒ R): ReductionRule2[Y, Z, R]

Definition Classes
Rule0
def ~~>[Z, R](f: (Z) ⇒ R): ReductionRule1[Z, R]

Definition Classes
Rule0
def ~~?[X, Y, Z](f: (X, Y, Z) ⇒ Boolean): PopRule3[X, Y, Z]

Definition Classes
Rule0
def ~~?[Y, Z](f: (Y, Z) ⇒ Boolean): PopRule2[Y, Z]

Definition Classes
Rule0
def ~~?[Z](f: (Z) ⇒ Boolean): PopRule1[Any]

Definition Classes
Rule0

Related Doc: package rules

class CharRule extends Rule0

Instance Constructors

new CharRule(c: Char)

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def -(upperBound: String): Rule0

final def ==(arg0: Any): Boolean

def append(other: Matcher): Matcher

def append(other: Rule): Matcher

def append(f: (Context[Any]) ⇒ Boolean): Matcher

def append(action: Action[_]): Matcher

def appendChoice(other: Matcher): Matcher

def appendChoice(other: Rule): Matcher

final def asInstanceOf[T0]: T0

val c: Char

def clone(): AnyRef

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 label(label: String): CharRule.this.type

val matcher: Matcher

def memoMismatches: CharRule.this.type

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def skipNode: CharRule.this.type

def suppressNode: CharRule.this.type

def suppressSubnodes: CharRule.this.type

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

def toString(): String

def unary_!: Rule0

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withMatcher(matcher: Matcher): CharRule.this.type

def |(other: Rule0): Rule0

def ~[A, B, C, D, E, F, G](other: Rule7[A, B, C, D, E, F, G]): Rule7[A, B, C, D, E, F, G]

def ~[A, B, C, D, E, F](other: Rule6[A, B, C, D, E, F]): Rule6[A, B, C, D, E, F]

def ~[A, B, C, D, E](other: Rule5[A, B, C, D, E]): Rule5[A, B, C, D, E]

def ~[A, B, C, D](other: Rule4[A, B, C, D]): Rule4[A, B, C, D]

def ~[A, B, C](other: Rule3[A, B, C]): Rule3[A, B, C]

def ~[A, B](other: Rule2[A, B]): Rule2[A, B]

def ~[A](other: Rule1[A]): Rule1[A]

def ~[Z, R](other: ReductionRule1[Z, R]): ReductionRule1[Z, R]

def ~[Y, Z, R](other: ReductionRule2[Y, Z, R]): ReductionRule2[Y, Z, R]

def ~[X, Y, Z, R](other: ReductionRule3[X, Y, Z, R]): ReductionRule3[X, Y, Z, R]

def ~[Z](other: PopRule1[Z]): PopRule1[Z]

def ~[Y, Z](other: PopRule2[Y, Z]): PopRule2[Y, Z]

def ~[X, Y, Z](other: PopRule3[X, Y, Z]): PopRule3[X, Y, Z]

def ~(other: Rule0): CharRule.this.type

def ~%(f: (String) ⇒ Unit): CharRule.this.type

def ~:%(f: (Char) ⇒ Unit): CharRule.this.type

def ~:>[R](f: (Char) ⇒ R): Rule1[R]

def ~:?(f: (Char) ⇒ Boolean): CharRule.this.type

def ~>[R](f: (String) ⇒ R): Rule1[R]

def ~>>[R](f: (IndexRange) ⇒ R): Rule1[R]

def ~?(f: (String) ⇒ Boolean): CharRule.this.type

def ~~%[X, Y, Z](f: (X, Y, Z) ⇒ Unit): PopRule3[X, Y, Z]

def ~~%[Y, Z](f: (Y, Z) ⇒ Unit): PopRule2[Y, Z]

def ~~%[Z](f: (Z) ⇒ Unit): PopRule1[Z]

def ~~>[X, Y, Z, R](f: (X, Y, Z) ⇒ R): ReductionRule3[X, Y, Z, R]

def ~~>[Y, Z, R](f: (Y, Z) ⇒ R): ReductionRule2[Y, Z, R]

def ~~>[Z, R](f: (Z) ⇒ R): ReductionRule1[Z, R]

def ~~?[X, Y, Z](f: (X, Y, Z) ⇒ Boolean): PopRule3[X, Y, Z]

def ~~?[Y, Z](f: (Y, Z) ⇒ Boolean): PopRule2[Y, Z]

def ~~?[Z](f: (Z) ⇒ Boolean): PopRule1[Any]

Inherited from Rule0

Inherited from Rule

Inherited from AnyRef

Inherited from Any

Ungrouped