char

Value Members

final def !=(arg0: Any): Boolean

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

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

Definition Classes
AnyRef → Any
val alphaChar: RegexC[Char]

Matches a single alphabetic character ('a', 'A', etc).
Matches a single alphabetic character ('a', 'A', etc). Could be represented in a regular expression as [:alpha:].
val alphaNumericChar: RegexC[Char]

Matches a single alphanumeric character ('0', 'a', 'A', etc).
Matches a single alphanumeric character ('0', 'a', 'A', etc). Could be represented in a regular expression as [:alnum:].
final def asInstanceOf[T0]: T0

Definition Classes
Any
val asciiChar: RegexC[Char]

A single ASCII character [ -~].
A single ASCII character [ -~]. Could be represented in a regular expression as [:ascii:].
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val controlChar: RegexC[Char]

A single control character [\x00-\x1F\x7F].
A single control character [\x00-\x1F\x7F]. Could be represented in a regular expression as [:cntrl:].
val digit: RegexC[Int]

Matches a single digit character ('0', '3', '9', etc).
Matches a single digit character ('0', '3', '9', etc). Could be represented in a regular expression as \d or [0-9].

See also
digitChar
val digitChar: RegexC[Char]

Matches a single digit character ('0', '3', '9', etc).
Matches a single digit character ('0', '3', '9', etc). Could be represented in a regular expression as \d or [0-9].

See also
digit
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
val graphChar: RegexC[Char]

A single visible (graphical) character [\x21-\x7E].
A single visible (graphical) character [\x21-\x7E]. Could be represented in a regular expression as [:graph:].
def hashCode(): Int

Definition Classes
AnyRef → Any
val hexDigitChar: RegexC[Char]

Matches a single hexadecimal digit ('0', '1', 'A', 'F', 'a', 'f', etc).
Matches a single hexadecimal digit ('0', '1', 'A', 'F', 'a', 'f', etc). Could be represented in a regular expression as [:xdigit:].
val horizontalWhitespaceChar: RegexC[Char]

A single horizontal whitespace character [\t ].
A single horizontal whitespace character [\t ]. Could be represented in a regular expression as \h.
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
val lowerAlphaChar: RegexC[Char]

Matches a single lowercase character ('a', 'z', etc).
Matches a single lowercase character ('a', 'z', etc). Could be represented in a regular expression as [a-z] or [:lower:].
def matchedS[Out](r: RegexC[Out]): RegexC[String]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
val nonAlphaChar: RegexC[Char]

Opposite of alphaChar.
Opposite of alphaChar. Could be represented in a regular expression as [^[:alalpha:]].
val nonAlphaNumericChar: RegexC[Char]

Opposite of alphaNumericChar.
Opposite of alphaNumericChar. Could be represented in a regular expression as [^[:alnum:]].
val nonAsciiChar: RegexC[Char]

Opposite of asciiChar.
Opposite of asciiChar. Could be represented in a regular expression as [^[:ascii:]].
val nonControlChar: RegexC[Char]

Opposite of controlChar.
Opposite of controlChar. Could be represented in a regular expression as [^[:cntrl:]].
val nonDigit: RegexC[Char]

Opposite of digit.
Opposite of digit. Could be represented in a regular expression as \D.
val nonGraphChar: RegexC[Char]

Opposite of graphChar.
Opposite of graphChar. Could be represented in a regular expression as [^[:graph:]].
val nonHexDigitChar: RegexC[Char]

Opposite of hexDigitChar.
Opposite of hexDigitChar. Could be represented in a regular expression as [^[:alnum:]].
val nonHorizontalWhitespaceChar: RegexC[Char]

Opposite of horizontalWhitespaceChar; this matches on any character that is not a tab or a space.
Opposite of horizontalWhitespaceChar; this matches on any character that is not a tab or a space. Could be represented in a regular expression as \H.
val nonLowerAlphaChar: RegexC[Char]

Opposite of lowerAlphaChar.
Opposite of lowerAlphaChar. Could be represented in a regular expression as [^{a-z] or [}[:lower:]].
val nonPrintableChar: RegexC[Char]

Opposite of printableChar.
Opposite of printableChar. Could be represented in a regular expression as [^[:print:]].
val nonPunctuationChar: RegexC[Char]

Opposite of punctuationChar.
Opposite of punctuationChar. Could be represented in a regular expression as [^[:punct:]].
val nonUpperAlphaChar: RegexC[Char]

Opposite of upperAlphaChar.
Opposite of upperAlphaChar. Could be represented in a regular expression as [^{a-z] or [}[:upper:]].
val nonWhitespaceChar: RegexC[Char]

Opposite of whitespaceChar.
Opposite of whitespaceChar. Could be represented in a regular expression as \S.
val nonWordChar: RegexC[Char]

Opposite of wordChar.
Opposite of wordChar. Could be represented in a regular expression as \W.
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val printableChar: RegexC[Char]

A single printable character (visible character or space).
A single printable character (visible character or space). Could be represented in a regular expression as [:print:] or \x20-\x7E.
val punctuationChar: RegexC[Char]

A single punctuation character (;, !, etc)..
A single punctuation character (;, !, etc).. Could be represented in a regular expression as [:punct:].
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
val upperAlphaChar: RegexC[Char]

Matches a single uppercase character ('a', 'z', etc).
Matches a single uppercase character ('a', 'z', etc). Could be represented in a regular expression as [a-z] or [:upper:].
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( ... )
val whitespaceChar: RegexC[Char]

A single whitespace character [\t\n\f\r ].
A single whitespace character [\t\n\f\r ]. Could be represented in a regular expression as \s.
def withMatchedS[Out](r: RegexC[Out]): RegexC[(String, Out)]
val wordChar: RegexC[Char]

Matches a single "word" character ('A', 'a', '_', etc).
Matches a single "word" character ('A', 'a', '_', etc). Could be represented in a regular expression as \w.

Related Doc: package regex

object char

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val alphaChar: RegexC[Char]

val alphaNumericChar: RegexC[Char]

final def asInstanceOf[T0]: T0

val asciiChar: RegexC[Char]

def clone(): AnyRef

val controlChar: RegexC[Char]

val digit: RegexC[Int]

val digitChar: RegexC[Char]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

val graphChar: RegexC[Char]

def hashCode(): Int

val hexDigitChar: RegexC[Char]

val horizontalWhitespaceChar: RegexC[Char]

final def isInstanceOf[T0]: Boolean

val lowerAlphaChar: RegexC[Char]

def matchedS[Out](r: RegexC[Out]): RegexC[String]

final def ne(arg0: AnyRef): Boolean

val nonAlphaChar: RegexC[Char]

val nonAlphaNumericChar: RegexC[Char]

val nonAsciiChar: RegexC[Char]

val nonControlChar: RegexC[Char]

val nonDigit: RegexC[Char]

val nonGraphChar: RegexC[Char]

val nonHexDigitChar: RegexC[Char]

val nonHorizontalWhitespaceChar: RegexC[Char]

val nonLowerAlphaChar: RegexC[Char]

val nonPrintableChar: RegexC[Char]

val nonPunctuationChar: RegexC[Char]

val nonUpperAlphaChar: RegexC[Char]

val nonWhitespaceChar: RegexC[Char]

val nonWordChar: RegexC[Char]

final def notify(): Unit

final def notifyAll(): Unit

val printableChar: RegexC[Char]

val punctuationChar: RegexC[Char]

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

def toString(): String

val upperAlphaChar: RegexC[Char]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

val whitespaceChar: RegexC[Char]

def withMatchedS[Out](r: RegexC[Out]): RegexC[(String, Out)]

val wordChar: RegexC[Char]

Inherited from AnyRef

Inherited from Any

Ungrouped