Struct egg::ENode

pub struct ENode<O, Child = Id> {
    pub op: O,
    pub children: SmallVec<[Child; 2]>,
}

An operator from the user-defined Language with some children.

An ENode is operator from the user-provided Language with zero or more children. Note that ENode is generic over both the Language and the type of the children. In the typical setting (inside and EClass), the children of an ENode are elcass Ids, so the second generic parameter defaults to Id. In other cases (cost functions or metadata), the generic parameter may be something else.

Fields

op: O

The operator from the user-defined Language

children: SmallVec<[Child; 2]>

The children of the ENode. In most cases, the child type is Id.

Methods

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

pub fn leaf(op: L) -> Self

Create a new ENode with no children. Equivalent to calling ENode::new with no children.

pub fn new<I>(op: L, children: I) -> Self where
    I: IntoIterator<Item = Child>, 

Create a new ENode.

pub fn try_new<Error, I>(op: L, children: I) -> Result<Self, Error> where
    I: IntoIterator<Item = Result<Child, Error>>, 

Try to create an ENode with a falliable child iterator.

Example

define_language! {
    enum Math {
        Num(i32),
        Add = "+",
        Mul = "*",
    }
}

// This is obviously silly, but maybe you have some more
// complex function
fn non_neg(i: i32) -> Result<u32, String> {
    if i >= 0 {
        Ok(i as u32)
    } else {
        Err(format!("{} is less than 0", i))
    }
}
let r1: Result<ENode<Math, u32>, String> = ENode::try_new(
    Math::Add,
    vec![non_neg(1), non_neg(8)]
);
let r2: Result<ENode<Math, u32>, String> = ENode::try_new(
    Math::Add,
    vec![non_neg(-1), non_neg(8)]
);
assert_eq!(r1, Ok(enode!(Math::Add, 1, 8)));
assert_eq!(r2, Err("-1 is less than 0".into()));

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

Create a new ENode by mapping a function over the children.

enode.map_children(f) is equivalent to:

ENode::new(
    enode.op.clone(),
    enode.children.iter().cloned().map(f),
)

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

Create a new ENode by mapping a falliable function over the children.

enode.map_children_result(f) is equivalent to:

ENode::try_new(
    enode.op.clone(),
    enode.children.iter().cloned().map(f),
)

Trait Implementations

impl<L> AsRef<ENode<L, RecExpr<L>>> for RecExpr<L>

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

Performs the conversion.

impl<L> Borrow<ENode<L, RecExpr<L>>> for RecExpr<L>

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

Immutably borrows from an owned value.

impl<O: Clone, Child: Clone> Clone for ENode<O, Child>

fn clone(&self) -> ENode<O, Child>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<O: Debug, Child: Debug> Debug for ENode<O, Child>

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

Formats the value using the given formatter.

impl<O: Eq, Child: Eq> Eq for ENode<O, Child>

impl<L> From<ENode<L, RecExpr<L>>> for RecExpr<L>

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

Performs the conversion.

impl<O: Hash, Child: Hash> Hash for ENode<O, Child>

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<O: PartialEq, Child: PartialEq> PartialEq<ENode<O, Child>> for ENode<O, Child>

fn eq(&self, other: &ENode<O, Child>) -> bool

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

fn ne(&self, other: &ENode<O, Child>) -> bool

This method tests for !=.

impl<O, Child> StructuralEq for ENode<O, Child>

impl<O, Child> StructuralPartialEq for ENode<O, Child>