Enum brzozowski_regex::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 over values of type S.

Variants

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>)

Implementations

impl<B: Builder> Regex<B>

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

where B: Clone, B::Symbol: Clone + Eq,

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

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

where B: Clone, B::Symbol: Clone + Eq, I: Borrow<B::Symbol>,

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

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

where B: Clone, B::Symbol: Clone + Eq, 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.

impl<B: Builder> Regex<B>

where B::Symbol: Clone,

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

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

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

where B::Symbol: Clone,

fn clone(&self) -> Regex<B>

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

fn c(self) -> Regex<B>

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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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> StructuralEq for Regex<B>

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