Enum Regex

pub enum Regex<B: Builder> {
    EmptySet,
    EmptyString,
    Symbol(B::Symbol),
    Concat(Box<Self>, Box<Self>),
    Closure(Box<Self>),
    Or(Box<Self>, Box<Self>),
    And(Box<Self>, Box<Self>),
    Complement(Box<Self>),
}

Data type describing regular expressions.

Variants

EmptySet

The empty set ∅

EmptyString

The empty string ε

Symbol(B::Symbol)

A symbol s

Concat(Box<Self>, Box<Self>)

Concatenation R S

Closure(Box<Self>)

Closure R*

Or(Box<Self>, Box<Self>)

Disjunction R | S

And(Box<Self>, Box<Self>)

Conjunction R & R

Complement(Box<Self>)

Complement ¬R

Implementations

impl<S: Alphabet> Regex<ApproximatelySimilarCanonical<S>>

pub fn to_automaton(&self) -> FiniteAutomaton<S>

Returns a finite automaton for this regular expression.

impl<B: Builder> Regex<B>

pub fn empty_set() -> Self

pub fn empty_string() -> Self

pub fn symbol(value: B::Symbol) -> Self

pub fn closure(inner: Self) -> Self

pub fn concat(left: Self, right: Self) -> Self

pub fn or(left: Self, right: Self) -> Self

pub fn and(left: Self, right: Self) -> Self

pub fn complement(inner: Self) -> Self

impl<B: Builder> Regex<B>

pub fn rebuild<X: Builder<Symbol = B::Symbol>>(&self) -> Regex<X>

Rebuild this regular expression using a different builder over the same symbol type.

impl<B: Builder> Regex<B>

pub fn derive_iter<I>(&self, symbols: impl IntoIterator<Item = I>) -> Regex<B>

where I: Borrow<B::Symbol>,

Returns the derivative of this regular expression w.r.t. the given symbols.

pub fn derive(&self, symbol: &B::Symbol) -> Regex<B>

Returns the derivative of this regular expression w.r.t. to the given symbol.

pub fn matches<I>(&self, symbols: impl IntoIterator<Item = I>) -> bool

where I: Borrow<B::Symbol>,

Returns whether the string of symbols is in the language of this regular expression.

impl<B: Builder> Regex<B>

pub fn is_nullable(&self) -> bool

Returns whether the empty string is in the language of this regular expression.

pub fn nullable(&self) -> Regex<B>

Returns empty string if this regular expression is nullable, otherwise returns empty set.

Trait Implementations

impl<B: Builder> Add for Regex<B>

type Output = Regex<B>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<B: Builder> BitAnd for Regex<B>

type Output = Regex<B>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<B: Builder> BitOr for Regex<B>

type Output = Regex<B>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<B: Builder> Clone for Regex<B>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B: Debug + Builder> Debug for Regex<B>

where B::Symbol: Debug,

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

Formats the value using the given formatter.

impl<B: Builder> Display for Regex<B>

where B::Symbol: Display,

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

Formats the value using the given formatter.

impl<B: Hash + Builder> Hash for Regex<B>

where B::Symbol: Hash,

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<B: Builder> Not for Regex<B>

type Output = Regex<B>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<B: PartialEq + Builder> PartialEq for Regex<B>

where B::Symbol: PartialEq,

fn eq(&self, other: &Regex<B>) -> 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<B: Eq + Builder> Eq for Regex<B>

where B::Symbol: Eq,

impl<B: Builder> StructuralPartialEq for Regex<B>