Enum rational_deduction::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

Checks if the Expr is atomic.

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

Checks 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, 

Extends 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, 

Substitutes 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.

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

Returns 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<'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, S> From<StoredShape<E, S>> for Expr<E> where
    E: Expression,
    S: Shape<E>, 

fn from(expr: StoredShape<E, S>) -> Self

Performs the conversion.

impl<E, V> From<Structure<E, V>> for Expr<E> where
    E: Expression,
    E::Group: FromIterator<E>,
    V: Container<Term<E>>, 

fn from(structure: Structure<E, V>) -> Self

Performs the conversion.

impl<E> From<Structure<E>> for Expr<E> where
    E: Expression,
    E::Group: FromIterator<E>, 

fn from(structure: Structure<E>) -> Self

Performs the conversion.

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.

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

Feeds a slice of this type into the given Hasher.

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> StructuralEq for Expr<E> where
    E: Expression, 

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

impl<E> TryFrom<Expr<E>> for Structure<E> where
    E: Expression,
    E::Group: IntoIterator<Item = E>, 

type Error = <Structure<E> as Matcher<E>>::Error

The type returned in the event of a conversion error.

fn try_from(expr: Expr<E>) -> Result<Self, Self::Error>

Performs the conversion.

impl<E, V> TryFrom<Expr<E>> for Structure<E, V> where
    E: Expression,
    E::Group: IntoIterator<Item = E>,
    V: Container<Term<E>>, 

type Error = <Structure<E, V> as Matcher<E>>::Error

The type returned in the event of a conversion error.

fn try_from(expr: Expr<E>) -> Result<Self, Self::Error>

Performs the conversion.

impl<E, S> TryFrom<Expr<E>> for StoredShape<E, S> where
    E: Expression,
    S: Shape<E>, 

type Error = <S as Matcher<E>>::Error

The type returned in the event of a conversion error.

fn try_from(expr: Expr<E>) -> Result<Self, Self::Error>

Performs the conversion.