RE1

def linear (groupNames: List[String] = Nil): (String, List[String])

def replicate (re: RE = re): RE1

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

lazy val % : Wrapped

Non-capturing group

lazy val * : KStar

Zero-or-more quantifier, greedy

lazy val *+ : KStar

Zero-or-more quantifier, possessive

lazy val *? : KStar

Zero-or-more quantifier, reluctant

lazy val + : KCross

One-or-more quantifier, greedy

lazy val ++ : KCross

One-or-more quantifier, possessive

lazy val +? : KCross

One-or-more quantifier, reluctant

def - (that: RE): RE

Unprotected concatenation

def /: [A] (z: A)(op: OpRewriter[A], order: TraversalOrder): (RE, A)

Recursively apply an (RE, A) => (RE, A) operation, going left to right.

def < (n: Int): RE

At-most-N quantifier, greedy

def <+ (n: Int): RE

At-most-N quantifier, possessive

def << [A] (extractor: MatchExtractor[A]): Extractor[A]

Generate an Extractor for this extracting MatchExtractor

def << [A] (extractor: (MatchGroup) ⇒ Option[A])(implicit d: DummyImplicit): Extractor[A]

Generate an Extractor for this extracting function

def << [A] (extractor: (Match) ⇒ Option[A]): Extractor[A]

Generate an Extractor for this extracting function

def <? (n: Int): RE

At-most-N quantifier, reluctant

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

def > (n: Int): RE

At-least-N quantifier, greedy

def >+ (n: Int): RE

At-least-N quantifier, possessive

def >? (n: Int): RE

At-least-N quantifier, reluctant

lazy val ? : Opt

Zero-or-one quantifier, greedy

lazy val ?! : RE

Negative look-ahead

lazy val ?+ : Opt

Zero-or-one quantifier, possessive

def ?: (flags: String): Wrapped

Non-capturing group with flags (local mode modifiers), infix operator "i" ?: re

lazy val ?<! : RE

Negative look-behind

lazy val ?<= : RE

Positive look-behind

lazy val ?= : RE

Positive look-ahead

lazy val ?> : RE

Atomic group

lazy val ?? : Opt

Zero-or-one quantifier, reluctant

def \ (name: String): Group

Named capturing group

lazy val ag : RE

Atomic group

def apply (): Group

Unnamed capturing group (actual unique name is generated)

def apply (n: Int): RE

Exactely-N quantifier

def apply (rg: (Int, Int)): RE

N-to-M quantifier

def apply (rg: Range): RE

N-to-M quantifier

def apply (lb: Int, ub: Int, mode: RepMode = Greedy): RepNToM

N-to-M quantifier

def asInstanceOf [T0] : T0

def clone (): AnyRef

def eq (arg0: AnyRef): Boolean

def equals (arg0: Any): Boolean

def finalize (): Unit

def foreach [U] (order: TraversalOrder)(f: (RE) ⇒ U): Unit

def g (): Group

Unnamed capturing group (actual unique name is generated)

def g (name: String): Group

Named capturing group

def getClass (): java.lang.Class[_]

lazy val groups : List[MatchGroup]

def hashCode (): Int

def isInstanceOf [T0] : Boolean

lazy val lin : (String, List[String])

Combined linearization: first term is String representation, second is the List of capturing group names

def linear (fn: (String) ⇒ String, groupNames: List[String]): (String, List[String])

def map (tr: Rewriter, order: TraversalOrder = TraversalOrder.Postfixed): RE

Recursively replace matching terms in the RE subtree

lazy val matchGroup : MatchGroup

Corresponding MatchGroup tree, with containing unnamed $0 MatchGroup

def ncg (flags: String): Wrapped

Non-capturing group with flags (local mode modifiers)

lazy val ncg : Wrapped

Non-capturing group

def ne (arg0: AnyRef): Boolean

def notify (): Unit

def notifyAll (): Unit

lazy val r : Regex

Scala Regex linearization

val re : RE

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

def toString (): String

String linearization

def traverse (order: TraversalOrder = TraversalOrder.Postfixed): Traversable[RE]

Return a Traversable for this order

def wait (): Unit

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

def wait (arg0: Long): Unit

def | (that: RE): Alt

Alternative

def ~ (that: RE): RE

Protected concatenation, both operands are wrapped in non-capturing groups if needed