Enum exprz::vec::MultiExpr

pub enum MultiExpr<A = (), G = ()> {
    Atom(A),
    Group(Vec<Self>, G),
}

This is supported on crate feature alloc only.

Vector MultiExpression Type

Variants

Atom(A)

Atomic Expression

Group(Vec<Self>, G)

Grouped Expression

Trait Implementations

impl<A: Clone, G: Clone> Clone for MultiExpr<A, G>

fn clone(&self) -> MultiExpr<A, G>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug, G: Debug> Debug for MultiExpr<A, G>

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

Formats the value using the given formatter.

impl<A, G> Default for MultiExpr<A, G> where
    G: Default, 

fn default() -> Self

Returns the “default value” for a type.

impl<A: Eq, G: Eq> Eq for MultiExpr<A, G>

impl<A, G> Expression for MultiExpr<A, G>

type Atom = A

Atomic Element Type

type Group = (Vec<Self>, G)

Group Expression Type

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

Returns a reference to the underlying Expression type.

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

Builds an Expression from an atomic element.

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

Builds an Expression from a grouped expression.

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

Converts from the canonical enumeration.

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

This is supported on crate feature parse only.

Parses a string into an Expression.

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

Checks if the Expression is atomic.

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

Checks 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 default_atom<T>() -> Self::Atom where
    Self::Atom: FromIterator<T>, 

Builds an empty atomic expression.

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

Builds an empty grouped expression.

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

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

fn empty_atom<T>() -> Self where
    Self::Atom: FromIterator<T>, 

Builds an empty atomic expression.

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

Builds an empty grouped expression.

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

Clones an Expression that has Clone-able Atoms.

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

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

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

fn matches<P>(&self, pattern: P) -> bool where
    P: Pattern<Self>, 

This is supported on crate feature pattern only.

Checks if expression matches given Pattern.

fn matches_equal<P>(&self, pattern: &P) -> bool where
    P: Expression,
    P::Atom: PartialEq<Self::Atom>, 

This is supported on crate feature pattern only.

Checks if self matches an equality pattern.

fn matches_subexpression<P>(&self, pattern: &P) -> bool where
    P: Expression,
    P::Atom: PartialEq<Self::Atom>, 

This is supported on crate feature pattern only.

Checks if self matches a subexpression pattern.

fn matches_basic_shape<P>(&self, pattern: &P) -> bool where
    P: Expression<Atom = BasicShape>,
    P::Atom: PartialEq<Self::Atom>, 

This is supported on crate feature pattern only.

Checks if self matches a basic shape pattern.

fn matches_wildcard<W, P>(&self, is_wildcard: W, pattern: &P) -> bool where
    P: Expression,
    P::Atom: PartialEq<Self::Atom>,
    W: Fn(&P::Atom) -> bool, 

This is supported on crate feature pattern only.

Checks if self matches a wildcard expression.

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

Extends a function on Atoms to a function on Expressions.

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

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

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

Substitutes an Expression into each Atom of self.

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

Substitutes an Expression into each Atom of &self.

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

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

Performs the conversion.

impl<'e, A, G> HasGroupType<'e, MultiExpr<A, G>, G> for <<MultiExpr<A, G> as Expression>::Group as IntoIteratorGen<MultiExpr<A, G>>>::IterGen

fn group_type(&self) -> &'e G

Returns underlying group type.

impl<A: Hash, G: Hash> Hash for MultiExpr<A, G>

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<A, G> IntoIteratorGen<MultiExpr<A, G>> for (Vec<MultiExpr<A, G>>, G)

type IterGen = (&'t Vec<MultiExpr<A, G>>, &'t G)

Underlying IteratorGen Type

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

Returns a new IteratorGen.

impl<A, G> IteratorGen<MultiExpr<A, G>> for (&Vec<MultiExpr<A, G>>, &G)

type Item = &'t MultiExpr<A, G>

type Iter = Iter<'t, MultiExpr<A, G>>

Underlying Iterator Type

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

Returns a new Iterator.

impl<A: PartialEq, G: PartialEq> PartialEq<MultiExpr<A, G>> for MultiExpr<A, G>

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

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

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

This method tests for !=.

impl<A, G> StructuralEq for MultiExpr<A, G>

impl<A, G> StructuralPartialEq for MultiExpr<A, G>