Enum exprz::vec::Expr

pub enum Expr<A> {
    Atom(A),
    Group(Vec<Self>),
}

Vector Expression Type

Variants

Atom(A)

Atomic expression

Group(Vec<Self>)

Grouped expression

Trait Implementations

impl<A: Clone> Clone for Expr<A>

fn clone(&self) -> Expr<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug> Debug for Expr<A>

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

Formats the value using the given formatter.

impl<A> Default for Expr<A>

fn default() -> Self

Returns the "default value" for a type.

impl<A: Eq> Eq for Expr<A>

impl<A> Expression for Expr<A>

type Atom = A

Atomic Element Type

type Group = Vec<Self>

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.

#[must_use]fn from_expr(expr: Expr<Self>) -> Self

Convert from the canonical enumeration.

fn from_str(s: &str) -> Result<Self, Error> where
    Self::Atom: FromIterator<char>,
    Self::Group: FromIterator<Self>, 

Parse a string into an Expression.

#[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 empty_atom<T>() -> Self where
    Self::Atom: FromIterator<T>, 

Build an empty atomic expression.

fn empty_group() -> Self where
    Self::Group: FromIterator<Self>, 

Build an empty grouped expression.

fn default() -> Self where
    Self::Group: FromIterator<Self>, 

Get the default value of an Expression: the empty group.

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 as Expression>::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 as Expression>::Atom>, 

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

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

Extend a function on Atoms to a function on Expressions.

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

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

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

Substitute an Expression into each Atom of self.

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

Substitute an Expression into each Atom of &self.

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

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

Performs the conversion.

impl<A: Hash> Hash for Expr<A>

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<A> IntoIteratorGen<Expr<A>> for Vec<Expr<A>>

type IterGen = &'t Vec<Expr<A>>

Underlying IteratorGen Type

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

Get a new IteratorGen.

impl<A, '_> IteratorGen<Expr<A>> for &'_ Vec<Expr<A>>

type Item = &'t Expr<A>

type Iter = Iter<'t, Expr<A>>

Underlying Iterator Type

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

Get a new Iterator.

impl<A: Ord> Ord for Expr<A>

fn cmp(&self, other: &Expr<A>) -> 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<A: PartialEq> PartialEq<Expr<A>> for Expr<A>

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

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

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

This method tests for !=.

impl<A: PartialOrd> PartialOrd<Expr<A>> for Expr<A>

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

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

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

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

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

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

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

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

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

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

impl<A> StructuralEq for Expr<A>

impl<A> StructuralPartialEq for Expr<A>