Enum exprz_core::Expr

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

Canonical Concrete Expression Type

Variants

Atom(E::Atom)

Atomic element

Group(E::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::Atom>

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

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

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

pub fn unwrap_atom(self) -> E::Atom

Returns the contained Atom value, consuming the self value.

pub fn unwrap_group(self) -> E::Group

Returns the contained Group value, consuming the self value.

Trait Implementations

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

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> Copy for Expr<E> where
    E: Expression,
    E::Atom: Copy,
    E::Group: Copy, 

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

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

Formats the value using the given formatter.

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

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

type Atom = E::Atom

Atomic element type

type Group = E::Group

Group expression type

fn cases(&self) -> ExprRef<'_, Self>

Get a reference to the underlying Expression type.

fn from_atom(atom: Self::Atom) -> Self

Build an Expression from an atomic element.

fn from_group(group: Self::Group) -> Self

Build an Expression from a grouped expression.

fn from_expr(expr: Expr<Self>) -> Self

Convert from the canonical enumeration.

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

Check if the Expression is atomic.

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

Check if the Expression is a grouped expression.

#[must_use]fn atom(self) -> Option<Self::Atom>

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

#[must_use]fn group(self) -> Option<Self::Group>

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

fn unwrap_atom(self) -> Self::Atom

Returns the contained Atom value, consuming the self value.

fn unwrap_group(self) -> Self::Group

Returns the contained Group value, consuming the self value.

fn clone(&self) -> Self where
    Self::Atom: Clone,
    Self::Group: FromIterator<Self>, 

Clone an Expression that has Clone-able Atoms.

fn eq<E>(&self, other: &E) -> bool where
    E: Expression,
    Self::Atom: PartialEq<E::Atom>, 

Check if two Expressions are equal using PartialEq on their Atoms.

fn is_subexpression<E>(&self, other: &E) -> bool where
    E: Expression,
    Self::Atom: PartialEq<E::Atom>, 

Check if an Expression is a sub-tree of another Expression using PartialEq on their Atoms.

fn map<E, F>(self, f: &mut F) -> E where
    E: Expression,
    E::Group: FromIterator<E>,
    F: FnMut(Self::Atom) -> E::Atom, 

Extend a function on Atoms to a function on Expressions.

fn map_ref<E, F>(&self, f: &mut F) -> E where
    E: Expression,
    E::Group: FromIterator<E>,
    F: FnMut(&Self::Atom) -> E::Atom, 

Extend a function on &Atoms to a function on &Expressions.

fn substitute<F>(self, f: &mut F) -> Self where
    Self::Group: FromIterator<Self>,
    F: FnMut(Self::Atom) -> Self, 

Substitute an Expression into each Atom of self.

fn substitute_from_iter<'s, I>(self, iter: &I) -> Self where
    Self::Atom: 's + PartialEq,
    Self::Group: FromIterator<Self>,
    I: IteratorGen<(&'s Self::Atom, Self)>, 

Use an iterator generator as a piecewise function to substitute an Expression into each Atom of self.

fn substitute_ref<F>(&self, f: &mut F) -> Self where
    Self::Group: FromIterator<Self>,
    F: FnMut(&Self::Atom) -> Self, 

Substitute an Expression into each Atom of &self.

fn substitute_ref_from_iter<'s, I>(&self, iter: &I) -> Self where
    Self: 's,
    Self::Atom: PartialEq + Clone,
    Self::Group: FromIterator<Self>,
    I: IteratorGen<(&'s Self::Atom, &'s Self)>, 

Use an iterator generator as a piecewise function to substitute an Expression into each Atom of &self.

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

fn from(e: E) -> Self

Performs the conversion.

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

fn from(expr_ref: ExprRef<'e, E>) -> Self

Performs the conversion.

impl<E: Hash> Hash for Expr<E> where
    E: Expression,
    E::Atom: Hash,
    E::Group: 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, 

Feeds a slice of this type into the given Hasher.

impl<E> IntoIteratorGen<Expr<E>> for E::Group where
    E: Expression, 

type IterGen = ExprIterContainer<E>

Underlying IteratorGen Type

fn gen(&self) -> Self::IterGen

Get a new IteratorGen.

fn new_iter(&self) -> <Self::IterGen as IteratorGen<T>>::Iter

Get an iterator from the underlying IterGen.

impl<E> IteratorGen<Expr<E>> for ExprIterContainer<E> where
    E: Expression, 

type Iter = ExprIter<E>

Underlying Iterator Type

fn iter(&self) -> Self::Iter

Get a new Iterator.

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

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> PartialEq<Expr<E>> for Expr<E> where
    E: Expression,
    E::Atom: PartialEq,
    E::Group: PartialEq, 

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

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

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

This method tests for !=.

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

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

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

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

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

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.

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

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

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,