Enum CompilerENode 

pub enum CompilerENode {
    Int(i64),
    Bool(bool),
    Float(u64),
    Var(u32, u32),
    Opaque(u32),
    Add(NodeId, NodeId),
    Sub(NodeId, NodeId),
    Mul(NodeId, NodeId),
    Div(NodeId, NodeId),
    Mod(NodeId, NodeId),
    Shl(NodeId, NodeId),
    Shr(NodeId, NodeId),
    BitXor(NodeId, NodeId),
    BitAnd(NodeId, NodeId),
    BitOr(NodeId, NodeId),
    And(NodeId, NodeId),
    Or(NodeId, NodeId),
    Not(NodeId),
    Eq(NodeId, NodeId),
    Ne(NodeId, NodeId),
    Lt(NodeId, NodeId),
    Le(NodeId, NodeId),
    Gt(NodeId, NodeId),
    Ge(NodeId, NodeId),
    Concat(NodeId, NodeId),
    Len(NodeId),
    Index(NodeId, NodeId),
    Copy(NodeId),
    Slice(NodeId, NodeId, NodeId),
    Contains(NodeId, NodeId),
}

Variants

Int(i64)

Bool(bool)

Float(u64)

f64 bit pattern. Floats are NEVER arithmetic-rewritten (no identity, no reassociation — bit-exactness is the contract); the variant exists so float-valued subtrees still participate in congruence.

Var(u32, u32)

(symbol index, version)

Opaque(u32)

Index into the converter’s originals table.

Add(NodeId, NodeId)

Sub(NodeId, NodeId)

Mul(NodeId, NodeId)

Div(NodeId, NodeId)

Mod(NodeId, NodeId)

Shl(NodeId, NodeId)

Shr(NodeId, NodeId)

BitXor(NodeId, NodeId)

BitAnd(NodeId, NodeId)

Bitwise &/| on Int (the surface &/| symbols; also what the mod-pow2 mask rule synthesizes).

BitOr(NodeId, NodeId)

And(NodeId, NodeId)

Logical and/or: truthiness in, Bool out, short-circuit. Rules consult class facts (is_bool) before rewriting.

Or(NodeId, NodeId)

Not(NodeId)

Eq(NodeId, NodeId)

Ne(NodeId, NodeId)

Lt(NodeId, NodeId)

Le(NodeId, NodeId)

Gt(NodeId, NodeId)

Ge(NodeId, NodeId)

Concat(NodeId, NodeId)

Len(NodeId)

Index(NodeId, NodeId)

Copy(NodeId)

copy of xs — a fresh, unaliased deep copy. Total.

Slice(NodeId, NodeId, NodeId)

xs sliced from a to b (1-based, inclusive). NON-total: raises on out-of-bounds, so rewrites may never delete one without proofs.

Contains(NodeId, NodeId)

xs contains x — membership. Total; modeled for congruence/CSE only (no rewrite touches its semantics).

Implementations

impl CompilerENode

pub fn children(&self) -> Vec<NodeId>

Children in evaluation order.

pub fn map_children(self, f: impl FnMut(NodeId) -> NodeId) -> Self

Rebuild the node with each child mapped (canonicalization).

pub fn op_is_total(&self) -> bool

Ops whose evaluation can never raise a runtime error, given total children. Div/Mod (zero divisor), Index/Slice (bounds), and Opaque (arbitrary effects) are the non-total ones — a rewrite may only DELETE a subterm whose whole tree is total, or it would erase the program’s error/effect behavior. Len/Copy/Contains raise KIND errors over non-collections, so they are non-total HERE and earn totality through class facts in super::CompilerEGraph::provably_total.

Trait Implementations

impl Clone for CompilerENode

fn clone(&self) -> CompilerENode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompilerENode

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

Formats the value using the given formatter.

impl Hash for CompilerENode

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 PartialEq for CompilerENode

fn eq(&self, other: &CompilerENode) -> 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 Copy for CompilerENode

impl Eq for CompilerENode

impl StructuralPartialEq for CompilerENode