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 visit_vars(&self, f: &mut impl FnMut(&Span, &Leaf))

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

pub fn map_symbols<Head2, Leaf2>( self, head: &mut impl FnMut(Head) -> Head2, leaf: &mut impl FnMut(Leaf) -> Leaf2, ) -> GenericAction<Head2, Leaf2>

where Head2: Clone + Display, Leaf2: Clone + Eq + Display + Hash,

Applies the provided head and leaf mappings to the action and all nested expressions.

pub fn make_unresolved(self) -> GenericAction<String, String>

Converts the action into its unresolved representation using String by formatting heads and leaves.

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