Enum exprz::Expr

pub enum Expr<E> where
    E: Expression,  {
    Atom(<E as Expression>::Atom),
    Group(<E as Expression>::Group),
}

Canonical Concrete Expression Type

Variants

Atom(<E as Expression>::Atom)

Atomic element

Group(<E as Expression>::Group)

Grouped expression

Implementations

impl<E> Expr<E> where
    E: Expression, 

#[must_use]pub fn is_atom(&self) -> bool

Check if the Expr is atomic.

#[must_use]pub fn is_group(&self) -> bool

Check if the Expr is a grouped expression.

#[must_use]pub fn atom(self) -> Option<<E as Expression>::Atom>

Converts from an Expr<E> to an Option<E::Atom>.

#[must_use]pub fn group(self) -> Option<<E as Expression>::Group>

Converts from an Expr<E> to an Option<E::Group>.

pub fn unwrap_atom(self) -> <E as Expression>::Atom

Returns the contained Atom value, consuming the self value.

Panics

Panics if the self value is a Group.

pub fn unwrap_group(self) -> <E as Expression>::Group

Returns the contained Group value, consuming the self value.

Panics

Panics if the self value is an Atom.

pub fn map<O, F>(self, f: F) -> O where
    F: FnMut(<E as Expression>::Atom) -> <O as Expression>::Atom,
    O: Expression,
    <E as Expression>::Group: IntoIterator,
    <O as Expression>::Group: FromIterator<O>,
    <<E as Expression>::Group as IntoIterator>::Item == E, 

Extend a function on Atoms to a function on Expressions.

pub fn substitute<F>(self, f: F) -> E where
    F: FnMut(<E as Expression>::Atom) -> E,
    <E as Expression>::Group: FromIterator<E>,
    <E as Expression>::Group: IntoIterator,
    <<E as Expression>::Group as IntoIterator>::Item == E, 

Substitute an Expression into each Atom of self.

Trait Implementations

impl<E> Clone for Expr<E> where
    E: Clone + Expression,
    <E as Expression>::Atom: Clone,
    <E as Expression>::Group: Clone, 

pub fn clone(&self) -> Expr<E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E> Copy for Expr<E> where
    E: Copy + Expression,
    <E as Expression>::Atom: Copy,
    <E as Expression>::Group: Copy, 

impl<E> Debug for Expr<E> where
    E: Debug + Expression,
    <E as Expression>::Atom: Debug,
    <E as Expression>::Group: Debug, 

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

Formats the value using the given formatter.

impl<E> Default for Expr<E> where
    E: Expression,
    <E as Expression>::Group: FromIterator<E>, 

pub fn default() -> Expr<E>

Default Expr

The default expression is the empty group expression.

impl<E> Eq for Expr<E> where
    E: Eq + Expression,
    <E as Expression>::Atom: Eq,
    <E as Expression>::Group: Eq, 

impl<A> From<Expr<A>> for Expr<Expr<A>>

fn from(expr: Expr<A>) -> Self

Performs the conversion.

impl<'e, E> From<ExprRef<'e, E>> for Expr<E> where
    E: Expression,
    <E as Expression>::Atom: Clone,
    <E as Expression>::Group: FromIterator<E>, 

#[must_use]pub fn from(expr_ref: ExprRef<'e, E>) -> Expr<E>

Performs the conversion.

impl<E> FromStr for Expr<E> where
    E: Expression,
    <E as Expression>::Atom: FromIterator<char>,
    <E as Expression>::Group: FromIterator<E>, 

type Err = Error

The associated error which can be returned from parsing.

pub fn from_str(s: &str) -> Result<Expr<E>, <Expr<E> as FromStr>::Err>

Parses a string s to return a value of this type.

impl<E> Hash for Expr<E> where
    E: Hash + Expression,
    <E as Expression>::Atom: Hash,
    <E as Expression>::Group: Hash, 

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<E> Ord for Expr<E> where
    E: Ord + Expression,
    <E as Expression>::Atom: Ord,
    <E as Expression>::Group: Ord, 

pub fn cmp(&self, other: &Expr<E>) -> Ordering

This method returns an Ordering between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<E> PartialEq<Expr<E>> for Expr<E> where
    E: PartialEq<E> + Expression,
    <E as Expression>::Atom: PartialEq<<E as Expression>::Atom>,
    <E as Expression>::Group: PartialEq<<E as Expression>::Group>, 

pub fn eq(&self, other: &Expr<E>) -> bool

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

pub fn ne(&self, other: &Expr<E>) -> bool

This method tests for !=.

impl<E> PartialOrd<Expr<E>> for Expr<E> where
    E: PartialOrd<E> + Expression,
    <E as Expression>::Atom: PartialOrd<<E as Expression>::Atom>,
    <E as Expression>::Group: PartialOrd<<E as Expression>::Group>, 

pub fn partial_cmp(&self, other: &Expr<E>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

pub fn lt(&self, other: &Expr<E>) -> bool

This method tests less than (for self and other) and is used by the < operator.

pub fn le(&self, other: &Expr<E>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

pub fn gt(&self, other: &Expr<E>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

pub fn ge(&self, other: &Expr<E>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<E> StructuralEq for Expr<E> where
    E: Expression, 

impl<E> StructuralPartialEq for Expr<E> where
    E: Expression,