Struct CompilerEGraph 

pub struct CompilerEGraph { /* private fields */ }

Implementations

impl CompilerEGraph

pub fn new() -> Self

pub fn node_count(&self) -> usize

pub fn find(&mut self, id: NodeId) -> NodeId

pub fn canonical_node(&mut self, id: NodeId) -> CompilerENode

The stored node with children mapped to their CURRENT class roots.

pub fn class_members(&mut self, id: NodeId) -> Vec<NodeId>

Member node ids of id’s class, in insertion order (deterministic).

pub fn add(&mut self, node: CompilerENode) -> NodeId

Hash-consing insert: an existing congruent node is returned instead of allocating. Literal leaves seed their own class facts.

pub fn union(&mut self, a: NodeId, b: NodeId) -> bool

Merge two classes. Facts intersect (both described the same value). Returns true if a merge actually happened.

pub fn rebuild(&mut self)

Restore the congruence invariant: parents of merged classes are re-canonicalized; newly congruent pairs are unioned (worklist).

pub fn set_scalar(&mut self, id: NodeId, kind: ScalarKind)

pub fn set_int_range(&mut self, id: NodeId, lo: i64, hi: i64)

pub fn scalar_of(&mut self, id: NodeId) -> Option<ScalarKind>

pub fn int_range(&mut self, id: NodeId) -> Option<(i64, i64)>

pub fn int_value(&mut self, id: NodeId) -> Option<i64>

A PROVEN single value (point interval) — sound grounds for folding.

pub fn proven_nonneg(&mut self, id: NodeId) -> bool

pub fn set_collection(&mut self, id: NodeId)

Mark the class a proven collection (list/text/map/set).

pub fn set_list(&mut self, id: NodeId)

Mark the class a proven LIST (implies collection).

pub fn proven_collection(&mut self, id: NodeId) -> bool

pub fn proven_list(&mut self, id: NodeId) -> bool

pub fn class_has_bool(&mut self, id: NodeId, b: bool) -> bool

Does the class contain the literal Bool(b)?

pub fn provably_total(&mut self, id: NodeId) -> bool

Whole-tree totality: the class has at least one member whose op is total and whose children are recursively total. A rewrite may only DELETE (stop evaluating) a provably total subterm — anything else could erase a runtime error or an effect. Bottom-up fixpoint, cycle-tolerant (cycles stay “not yet proven” until a leaf grounds them).

Totality is FACT-CONDITIONAL where the op’s only failure mode is a kind error: Len/Copy/Contains never raise over a PROVEN collection, and raise a type error over anything unproven — so without the fact they stay non-total, exactly like fold.rs’s fail-closed expr_is_total.

pub fn saturate(&mut self, rules: &[Rewrite])

Budgeted equality saturation: deterministic node order × rule order, unions applied immediately, congruence repaired per iteration. Stops at fixpoint, iteration cap, or the node-bank cap.

Trait Implementations

impl Default for CompilerEGraph

fn default() -> Self

Returns the “default value” for a type.