Enum egg::expr::Expr

pub enum Expr<L: Language, Child> {
    Constant(L::Constant),
    Variable(L::Variable),
    Operator(L::Operator, Vec<Child>),
}

Variants

Constant(L::Constant)Variable(L::Variable)Operator(L::Operator, Vec<Child>)

Methods

impl<L: Language, Child> Expr<L, Child>

pub fn map_children_result<Child2, F, Error>(
    &self,
    f: F
) -> Result<Expr<L, Child2>, Error> where
    Child: Clone,
    F: FnMut(Child) -> Result<Child2, Error>, 

pub fn map_children<Child2, F>(&self, f: F) -> Expr<L, Child2> where
    Child: Clone,
    F: FnMut(Child) -> Child2, 

pub fn children(&self) -> &[Child]

pub fn symbol(&self) -> Symbol<L, Child>

impl<L: Language> Expr<L, Id>

pub fn update_ids<V>(&self, unionfind: &UnionFind<Id, V>) -> Self

Trait Implementations

impl<L: Clone + Language, Child: Clone> Clone for Expr<L, Child> where
    L::Constant: Clone,
    L::Variable: Clone,
    L::Operator: Clone, 

fn clone(&self) -> Expr<L, Child>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L: Language> From<Expr<L, RecExpr<L>>> for RecExpr<L>

fn from(inner: Expr<L, RecExpr<L>>) -> Self

Performs the conversion.

impl<L: Language> AsRef<Expr<L, RecExpr<L>>> for RecExpr<L>

fn as_ref(&self) -> &Expr<L, RecExpr<L>>

Performs the conversion.

impl<L: Eq + Language, Child: Eq> Eq for Expr<L, Child> where
    L::Constant: Eq,
    L::Variable: Eq,
    L::Operator: Eq, 

impl<L: PartialEq + Language, Child: PartialEq> PartialEq<Expr<L, Child>> for Expr<L, Child> where
    L::Constant: PartialEq,
    L::Variable: PartialEq,
    L::Operator: PartialEq, 

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

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

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

This method tests for !=.

impl<L: Hash + Language, Child: Hash> Hash for Expr<L, Child> where
    L::Constant: Hash,
    L::Variable: Hash,
    L::Operator: 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<L: Debug + Language, Child: Debug> Debug for Expr<L, Child> where
    L::Constant: Debug,
    L::Variable: Debug,
    L::Operator: Debug, 

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

Formats the value using the given formatter.

impl<L: Language> Borrow<Expr<L, RecExpr<L>>> for RecExpr<L>

fn borrow(&self) -> &Expr<L, RecExpr<L>>

Immutably borrows from an owned value.