Enum ReOp 

pub enum ReOp {
    Literal(SmtString),
    Range(CharRange),
    None,
    Any,
    All,
    Concat(SmallVec<[Regex; 2]>),
    Union(SmallVec<[Regex; 2]>),
    Inter(SmallVec<[Regex; 2]>),
    Star(Regex),
    Plus(Regex),
    Opt(Regex),
    Diff(Regex, Regex),
    Comp(Regex),
    Pow(Regex, u32),
    Loop(Regex, u32, u32),
}

The core operations that define a regular expression.

This enum represents the different building blocks of a regular expression, including base cases (such as literals and predefined sets) and derived operations (such as concatenation, union, and intersection).

Structure Sharing

Many variants use reference-counted pointers (Rc<Regex>) to enable structural sharing and deduplication of sub-expressions. This ensures that identical sub-expressions are only computed once, improving efficiency.

Base Cases

These represent fundamental building blocks of regular expressions:

• Literal: A constant word.
• Range: A set of characters in a specific range.
• None: The empty set, which matches no words.
• Any: The set of all possible one-character strings.
• All: The set of all words, including the empty word.

Derived Operations

These are higher-level operations built from the base cases:

• Concatenation (Concat): Sequences two or more regular expressions.
• Union (Union): Represents the union (alternation) of two or more regexes.
• Intersection (Inter): Matches only strings present in both regexes.
• Star (Star): The Kleene star (r*), allowing zero or more repetitions.
• Plus (Plus): The positive closure (r+), requiring at least one repetition.
• Optional (Opt): Matches either a regex or the empty word (r?).
• Difference (Diff): Matches words in one regex but not in another.
• Complement (Comp): Matches everything except what a regex matches.
• Power (Pow): Repeats a regex exactly n times (r^n).
• Loop (Loop): Matches repetitions of a regex within a given range [l, u].

Variants

Literal(SmtString)

A constant (possibly empty) word.

Range(CharRange)

A range of characters.

None

The empty set (∅), which matches no strings.

Any

The set of all one-character strings. Independent of the alphabet.

All

The set of all possible words, including the empty word.

Concat(SmallVec<[Regex; 2]>)

The concatenation of two or more regular expressions. Matches words formed by appending matches of each sub-expression in sequence.

Union(SmallVec<[Regex; 2]>)

The union (alternation) of two or more regular expressions. Matches words accepted by at least one of the sub-expressions.

Inter(SmallVec<[Regex; 2]>)

The intersection of two or more regular expressions. Matches only words present in all sub-expressions.

Star(Regex)

The Kleene star (r*). Matches zero or more repetitions of the regex.

Plus(Regex)

The positive closure (r+). Matches one or more repetitions of the regex.

Opt(Regex)

The optional operator (r?). Matches either the regex or the empty word (ε).

Diff(Regex, Regex)

The difference (r1 - r2). Matches words in r1 that are not in r2.

Comp(Regex)

The complement (¬r). Matches all words except those in the regex.

Pow(Regex, u32)

The power operation (r^n). Matches exactly n repetitions of the regex.

Loop(Regex, u32, u32)

The bounded repetition (r[l, u]). Matches between l and u repetitions.

Trait Implementations

impl Clone for ReOp

fn clone(&self) -> ReOp

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ReOp

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for ReOp

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for ReOp

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ReOp

fn eq(&self, other: &ReOp) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ReOp

impl StructuralPartialEq for ReOp