Enum GenericAction

pub enum GenericAction<Head, Leaf>
where
    Head: Clone + Display,
    Leaf: Clone + PartialEq + Eq + Display + Hash,
{
    Let(Span, Leaf, GenericExpr<Head, Leaf>),
    Set(Span, Head, Vec<GenericExpr<Head, Leaf>>, GenericExpr<Head, Leaf>),
    Change(Span, Change, Head, Vec<GenericExpr<Head, Leaf>>),
    Union(Span, GenericExpr<Head, Leaf>, GenericExpr<Head, Leaf>),
    Panic(Span, String),
    Expr(Span, GenericExpr<Head, Leaf>),
}

Variants

Let(Span, Leaf, GenericExpr<Head, Leaf>)

Bind a variable to a particular datatype or primitive. At the top level (in a Command::Action), this defines a global variable. In a Command::Rule, this defines a local variable in the actions.

Set(Span, Head, Vec<GenericExpr<Head, Leaf>>, GenericExpr<Head, Leaf>)

set a function to a particular result. set should not be used on datatypes- instead, use union.

Change(Span, Change, Head, Vec<GenericExpr<Head, Leaf>>)

Delete or subsume (mark as hidden from future rewrites and unextractable) an entry from a function.

Union(Span, GenericExpr<Head, Leaf>, GenericExpr<Head, Leaf>)

union two datatypes, making them equal in the implicit, global equality relation of egglog. All rules match modulo this equality relation.

Example:

(datatype Math (Num i64))
(union (Num 1) (Num 2)); Define that Num 1 and Num 2 are equivalent
(extract (Num 1)); Extracts Num 1
(extract (Num 2)); Extracts Num 1

Panic(Span, String)

Expr(Span, GenericExpr<Head, Leaf>)

Implementations

impl<Head, Leaf> GenericAction<Head, Leaf>

where Head: Clone + Display, Leaf: Clone + Eq + Display + Hash,

pub fn map_exprs( &self, f: &mut impl FnMut(&GenericExpr<Head, Leaf>) -> GenericExpr<Head, Leaf>, ) -> Self

pub fn visit_exprs( self, f: &mut impl FnMut(GenericExpr<Head, Leaf>) -> GenericExpr<Head, Leaf>, ) -> Self

Applys f to all sub-expressions (including self) bottom-up, collecting the results.

pub fn subst( &self, subst: &mut impl FnMut(&Span, &Leaf) -> GenericExpr<Head, Leaf>, ) -> Self

pub fn map_def_use(self, fvar: &mut impl FnMut(Leaf, bool) -> Leaf) -> Self

Trait Implementations

impl<Head, Leaf> Clone for GenericAction<Head, Leaf>

where Head: Clone + Display + Clone, Leaf: Clone + PartialEq + Eq + Display + Hash + Clone,

fn clone(&self) -> GenericAction<Head, Leaf>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Head, Leaf> Debug for GenericAction<Head, Leaf>

where Head: Clone + Display + Debug, Leaf: Clone + PartialEq + Eq + Display + Hash + Debug,

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

Formats the value using the given formatter.

impl<Head, Leaf> Display for GenericAction<Head, Leaf>

where Head: Clone + Display, Leaf: Clone + PartialEq + Eq + Display + Hash,

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

Formats the value using the given formatter.

impl<Head, Leaf> Hash for GenericAction<Head, Leaf>

where Head: Clone + Display + Hash, Leaf: Clone + PartialEq + Eq + Display + Hash + 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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<Head, Leaf> PartialEq for GenericAction<Head, Leaf>

where Head: Clone + Display + PartialEq, Leaf: Clone + PartialEq + Eq + Display + Hash + PartialEq,

fn eq(&self, other: &GenericAction<Head, Leaf>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Head, Leaf> Eq for GenericAction<Head, Leaf>

where Head: Clone + Display + Eq, Leaf: Clone + PartialEq + Eq + Display + Hash + Eq,

impl<Head, Leaf> StructuralPartialEq for GenericAction<Head, Leaf>

where Head: Clone + Display, Leaf: Clone + PartialEq + Eq + Display + Hash,