Enum SLTNode 

pub enum SLTNode<A: Hash + Eq + Clone> {
    Input {
        variable: A,
        signed: bool,
        index: Vec<SLTIndex>,
        access: BitAccess,
    },
    Constant(BigUint, BigUint, usize, bool),
    Binary(NodeId, BinaryOp, NodeId),
    Unary(UnaryOp, NodeId),
    Mux {
        cond: NodeId,
        then_expr: NodeId,
        else_expr: NodeId,
    },
    ForFold {

        loop_var: A,
        loop_width: usize,
        loop_signed: bool,
        start: SLTLoopBound,
        end: SLTLoopBound,
        inclusive: bool,
        step: usize,
        step_op: SLTStepOp,
        reverse: bool,
        result: SLTForFoldResult<A>,
        initials: Vec<SLTForUpdate<A>>,
        updates: Vec<SLTForUpdate<A>>,
        effects: Vec<SLTForEffect>,
        continue_cond: NodeId,
    
},
    ForFoldGroup {
        loop_var: A,
        loop_width: usize,
        loop_signed: bool,
        start: BigInt,
        step: BigInt,
        trip_count: usize,
        entry_guard: NodeId,
        states: Vec<SLTForFoldGroupState<A>>,
    },
    Concat(Vec<(NodeId, usize)>),
    Slice {
        expr: NodeId,
        access: BitAccess,
    },
    Capture {
        expr: NodeId,
        key: u64,
    },
}

Variants

Input

Fields

variable: A

signed: bool

index: Vec<SLTIndex>

access: BitAccess

Constant(BigUint, BigUint, usize, bool)

Binary(NodeId, BinaryOp, NodeId)

Unary(UnaryOp, NodeId)

Mux

Fields

cond: NodeId

then_expr: NodeId

else_expr: NodeId

ForFold

Fields

loop_var: A

loop_width: usize

loop_signed: bool

start: SLTLoopBound

end: SLTLoopBound

inclusive: bool

step: usize

step_op: SLTStepOp

reverse: bool

result: SLTForFoldResult<A>

initials: Vec<SLTForUpdate<A>>

updates: Vec<SLTForUpdate<A>>

effects: Vec<SLTForEffect>

continue_cond: NodeId

ForFoldGroup

A fixed-trip-count fold carrying multiple state values and returning their final values as one packed result.

Fields

loop_var: A

loop_width: usize

loop_signed: bool

start: BigInt

step: BigInt

trip_count: usize

entry_guard: NodeId

states: Vec<SLTForFoldGroupState<A>>

Concat(Vec<(NodeId, usize)>)

Slice

Fields

expr: NodeId

access: BitAccess

Capture

A value materialized at a specific semantic evaluation position.

key keeps captures from distinct runtime-event operands separate even when their expressions are structurally identical.

Fields

expr: NodeId

key: u64

Implementations

impl<A: Hash + Eq + Clone> SLTNode<A>

pub fn fmt_expression( &self, f: &mut Formatter<'_>, arena: &SLTNodeArena<A>, ) -> Result

where A: Display,

impl<A: Debug + Display + Hash + Eq + Clone> SLTNode<A>

pub fn map_addr<B, F>( &self, id: NodeId, arena: &SLTNodeArena<A>, target_arena: &mut SLTNodeArena<B>, cache: &mut HashMap<NodeId, NodeId>, f: &F, ) -> Result<NodeId, SLTNodeFactsError>

where A: Hash + Eq + Clone, B: Hash + Eq + Clone, F: Fn(&A) -> B,

Maps the address type A to B throughout the reachable graph.

The traversal is explicitly postorder so deeply nested expressions do not consume the host thread’s call stack.

impl<A: Debug + Display + Hash + Eq + Clone> SLTNode<A>

Display implementation for SLTNode - provides human-readable tree structure

This implementation formats the Signal Logic Tree (SLT) as a hierarchical ASCII tree, making it easy to visualize the expression structure. Each node type displays relevant information:

• Input: Shows variable ID, dynamic indices (if any), and bit range [lsb:msb]
• Constant: Displays the value in hexadecimal and width in bits
• Binary: Shows the operation and recursively formats both operands with indentation
• Unary: Shows the operation and recursively formats the inner expression
• Mux: Displays condition, then-branch, and else-branch with clear labels
• Concat: Lists concatenated parts with their widths
• Slice: Shows the bit range extraction with the inner expression

Example

A binary expression a + b would display as:

Binary(Add)
  Const(0x1, 32bits)
  Const(0x2, 32bits)

A more complex expression (a + b) * (c - d) would show:

Binary(Mul)
  Binary(Add)
    Const(0x1, 32bits)
    Const(0x2, 32bits)
  Binary(Sub)
    Const(0x3, 32bits)
    Const(0x4, 32bits)

pub fn fmt_display( &self, f: &mut Formatter<'_>, arena: &SLTNodeArena<A>, ) -> Result

Trait Implementations

impl<A: Clone + Hash + Eq + Clone> Clone for SLTNode<A>

fn clone(&self) -> SLTNode<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug + Hash + Eq + Clone> Debug for SLTNode<A>

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

Formats the value using the given formatter.

impl<'de, A> Deserialize<'de> for SLTNode<A>

where A: Deserialize<'de> + Hash + Eq + Clone,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A: Eq + Hash + Eq + Clone> Eq for SLTNode<A>

impl<A: Hash + Hash + Eq + Clone> Hash for SLTNode<A>

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<A: PartialEq + Hash + Eq + Clone> PartialEq for SLTNode<A>

fn eq(&self, other: &SLTNode<A>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<A> Serialize for SLTNode<A>

where A: Serialize + Clone + Hash + Eq,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<A: PartialEq + Hash + Eq + Clone> StructuralPartialEq for SLTNode<A>