Struct ClassicalExpr 

pub struct ClassicalExpr { /* private fields */ }

A typed, side-effect-free runtime classical expression.

The expression node kind is exposed through ClassicalExpr::kind for inspection and tooling. Prefer the typed constructors on this type when building expressions; they centralize type checks and keep the AST valid.

Implementations

impl ClassicalExpr

pub fn var(var: ClassicalVar) -> Self

Creates an expression that reads the current runtime value of var.

pub fn value(value: ClassicalValue) -> Self

Creates an expression that reads an immutable runtime classical value.

pub fn bool_literal(value: bool) -> Self

Creates a boolean literal expression.

pub fn bit_literal(value: bool) -> Self

Creates a bit literal expression.

pub fn uint_literal(width: u32, value: u128) -> Result<Self, CircuitError>

Creates an unsigned integer literal with a non-zero width.

Literal construction currently supports constants up to 128 bits wide.

pub fn bit_vec_literal(width: u32, value: u128) -> Result<Self, CircuitError>

Creates a bit-vector literal with a non-zero width.

Literal construction currently supports constants up to 128 bits wide.

pub fn ty(&self) -> ClassicalType

Returns this expression’s static type.

pub fn kind(&self) -> &ClassicalExprKind

Returns the expression node kind.

This exposes the classical expression AST for inspection. Prefer the typed constructors on ClassicalExpr when building expressions so expression invariants remain centralized.

pub fn remap_classical_ids( &self, var_map: &HashMap<ClassicalVar, ClassicalVar>, value_map: &HashMap<ClassicalValue, ClassicalValue>, ) -> Result<Self, CircuitError>

Returns a copy of this expression with circuit-local classical handles remapped.

Every ClassicalVar and ClassicalValue referenced by this expression must have an entry in the corresponding map. Literal and structural nodes keep their static type and shape.

pub fn vars(&self) -> BTreeSet<ClassicalVar>

Returns all runtime classical variables read by this expression.

pub fn values(&self) -> BTreeSet<ClassicalValue>

Returns all immutable runtime classical values read by this expression.

pub fn collect_vars(&self, out: &mut BTreeSet<ClassicalVar>)

Adds every runtime classical variable read by this expression to out.

pub fn collect_values(&self, out: &mut BTreeSet<ClassicalValue>)

Adds every immutable runtime classical value read by this expression to out.

pub fn try_not(expr: impl Into<Self>) -> Result<Self, CircuitError>

Creates a not expression for Bool or Bit values.

pub fn try_and( lhs: impl Into<Self>, rhs: impl Into<Self>, ) -> Result<Self, CircuitError>

Creates an and expression for matching Bool or matching Bit values.

pub fn try_or( lhs: impl Into<Self>, rhs: impl Into<Self>, ) -> Result<Self, CircuitError>

Creates an or expression for matching Bool or matching Bit values.

pub fn try_xor( lhs: impl Into<Self>, rhs: impl Into<Self>, ) -> Result<Self, CircuitError>

Creates an xor expression for matching Bool or matching Bit values.

pub fn eq(lhs: Self, rhs: Self) -> Result<Self, CircuitError>

Creates an equality comparison. Operands must have the same type.

pub fn ne(lhs: Self, rhs: Self) -> Result<Self, CircuitError>

Creates an inequality comparison. Operands must have the same type.

pub fn lt(lhs: Self, rhs: Self) -> Result<Self, CircuitError>

Creates an unsigned less-than comparison.

pub fn le(lhs: Self, rhs: Self) -> Result<Self, CircuitError>

Creates an unsigned less-than-or-equal comparison.

pub fn gt(lhs: Self, rhs: Self) -> Result<Self, CircuitError>

Creates an unsigned greater-than comparison.

pub fn ge(lhs: Self, rhs: Self) -> Result<Self, CircuitError>

Creates an unsigned greater-than-or-equal comparison.

pub fn bit_to_bool(expr: Self) -> Result<Self, CircuitError>

Explicitly casts a Bit expression to Bool.

pub fn bit_vec_to_uint(expr: Self) -> Result<Self, CircuitError>

Explicitly casts a BitVec expression to a little-endian UInt.

pub fn to_bool(self) -> Result<Self, CircuitError>

Converts this Bit expression to Bool.

pub fn to_uint(self) -> Result<Self, CircuitError>

Converts this BitVec expression to a little-endian UInt.

pub fn select( condition: Self, then_expr: Self, else_expr: Self, ) -> Result<Self, CircuitError>

Creates an expression that chooses between two same-typed values.

pub fn extract_bit(value: Self, index: u32) -> Result<Self, CircuitError>

Extracts a single bit from a BitVec or UInt.

Index 0 is the least-significant bit.

pub fn extract_bits( value: Self, offset: u32, width: u32, ) -> Result<Self, CircuitError>

Extracts a bit range from a BitVec or UInt.

offset is little-endian: offset 0 starts at the least-significant bit.

pub fn concat( parts: impl IntoIterator<Item = Self>, ) -> Result<Self, CircuitError>

Concatenates bit-vector values into a larger bit-vector.

The first part occupies the least-significant output bits.

pub fn is_bool_true(&self) -> bool

Returns true when this expression is the boolean literal true.

pub fn is_bool_false(&self) -> bool

Returns true when this expression is the boolean literal false.

pub fn is_bit_true(&self) -> bool

Returns true when this expression is the bit literal true (1).

pub fn is_bit_false(&self) -> bool

Returns true when this expression is the bit literal false (0).

pub fn simplified(&self) -> Self

Returns a structurally simplified copy of this expression.

Simplification eliminates literal-driven redundancies and algebraic identities without evaluating runtime variable or value reads. It is idempotent: applying it twice yields the same expression.

See simplify for the full rule set.

pub fn pack_bits( bits: impl IntoIterator<Item = Self>, ) -> Result<Self, CircuitError>

Packs single-bit expressions into a BitVec.

The first bit becomes output index 0, the least-significant bit.

Trait Implementations

impl<Rhs> BitAnd<Rhs> for ClassicalExpr

where Rhs: Into<ClassicalExpr>,

type Output = ClassicalExpr

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<Rhs> BitOr<Rhs> for ClassicalExpr

where Rhs: Into<ClassicalExpr>,

type Output = ClassicalExpr

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<Rhs> BitXor<Rhs> for ClassicalExpr

where Rhs: Into<ClassicalExpr>,

type Output = ClassicalExpr

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Rhs) -> Self::Output

Performs the ^ operation.

impl Clone for ClassicalExpr

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ClassicalExpr

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

Formats the value using the given formatter.

impl Eq for ClassicalExpr

impl From<ClassicalValue> for ClassicalExpr

fn from(value: ClassicalValue) -> Self

Converts to this type from the input type.

impl From<ClassicalVar> for ClassicalExpr

fn from(var: ClassicalVar) -> Self

Converts to this type from the input type.

impl Hash for ClassicalExpr

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 Not for ClassicalExpr

type Output = ClassicalExpr

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation using logical or bitwise negation.

impl PartialEq for ClassicalExpr

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ClassicalExpr