Struct egg::egraph::EGraph

pub struct EGraph<L: Language, M> { /* fields omitted */ }

Data structure to keep track of equalities between expressions

Methods

impl<L: Language, M> EGraph<L, M>

pub fn classes(&self) -> impl Iterator<Item = &EClass<L, M>>

pub fn is_empty(&self) -> bool

pub fn total_size(&self) -> usize

Returns the number of nodes in the EGraph.

Actually returns the size of the hash cons index.

let mut egraph = EGraph::<TestLang, ()>::default();
let x = egraph.add(var("x"));
let y = egraph.add(var("y"));
// only one eclass
egraph.union(x.id, y.id);

assert_eq!(egraph.total_size(), 2);

pub fn number_of_classes(&self) -> usize

pub fn get_eclass(&self, eclass_id: Id) -> &EClass<L, M>

pub fn just_find(&self, id: Id) -> Id

impl<L: Language, M: Metadata<L>> EGraph<L, M>

pub fn from_expr(expr: &RecExpr<L>) -> (Self, Id)

pub fn add_expr(&mut self, expr: &RecExpr<L>) -> Id

pub fn add(&mut self, enode: Expr<L, Id>) -> AddResult

pub fn equivs(&self, expr1: &RecExpr<L>, expr2: &RecExpr<L>) -> Vec<Id>

pub fn prune(&mut self) -> usize

Trims down eclasses that have variables or constants in them.

If an eclass has a variable or consant in it, this will remove everything else from that eclass except those variables/constants.

let expr = TestLang.parse_expr("(+ x y)").unwrap();
let (mut egraph, root) = EGraph::<TestLang, ()>::from_expr(&expr);
let z = egraph.add(var("z"));
let eclass = egraph.union(root, z.id);
// eclass has z and + in it
assert_eq!(egraph.get_eclass(eclass).len(), 2);
// pruning will remove the +, returning how many nodes were removed
assert_eq!(egraph.prune(), 1);
// eclass is now smaller
assert_eq!(egraph.get_eclass(eclass).len(), 1);
// for now, its not actually removed from the egraph
assert_eq!(egraph.total_size(), 4);

pub fn fold_constants(&mut self) -> usize

pub fn rebuild(&mut self)

pub fn union(&mut self, id1: Id, id2: Id) -> Id

pub fn dump_dot(&self, filename: &str) where
    L::Constant: Display,
    L::Variable: Display,
    L::Operator: Display, 

Trait Implementations

impl<L: Language, M> Default for EGraph<L, M>

fn default() -> EGraph<L, M>

Returns the "default value" for a type.

impl<L: Debug + Language, M: Debug> Debug for EGraph<L, M>

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

Formats the value using the given formatter.