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

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

Panics

Panics if the self value is a Group.

pub fn unwrap_group(self) -> E::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
    E::Group: IntoIterator<Item = E>,
    O: Expression,
    O::Group: FromIterator<O>,
    F: FnMut(E::Atom) -> O::Atom, 

Extends a function on Atoms to a function on Expressions.

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

Substitutes an Expression into each Atom of self.

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.

pub 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> Default for Expr<E> where
    E: Expression,
    E::Group: FromIterator<E>, 

fn default() -> Self

Returns the empty group expression.

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

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

This is supported on crate feature alloc only.

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

Performs the conversion.

impl<T> From<Expr<T, usize, usize>> for Expr<Expr<T>>

This is supported on crate feature buffered only.

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

Performs the conversion.

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

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

Performs the conversion.

impl<A, G> From<MultiExpr<A, G>> for Expr<MultiExpr<A, G>>

This is supported on crate feature alloc only.

fn from(expr: MultiExpr<A, G>) -> Self

Performs the conversion.

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

This is supported on crate feature parse only.

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

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

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.

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

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