Enum egglog::ast::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>),
    Extract(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

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

extract a datatype from the egraph, choosing the smallest representative. By default, each constructor costs 1 to extract (common subexpressions are not shared in the cost model). The second argument is the number of variants to extract, picking different terms in the same equivalence class.

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

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

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

This method 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,