Enum ClassicalExprKind 

pub enum ClassicalExprKind {
    Var(ClassicalVar),
    Value(ClassicalValue),
    BoolLiteral(bool),
    BitLiteral(bool),
    UIntLiteral {
        width: NonZeroU32,
        value: u128,
    },
    BitVecLiteral {
        width: NonZeroU32,
        value: u128,
    },
    Unary {
        op: ClassicalUnaryOp,
        expr: ClassicalExpr,
    },
    Binary {
        op: ClassicalBinaryOp,
        lhs: ClassicalExpr,
        rhs: ClassicalExpr,
    },
    Compare {
        op: ClassicalCompareOp,
        lhs: ClassicalExpr,
        rhs: ClassicalExpr,
    },
    Cast {
        cast: ClassicalCast,
        expr: ClassicalExpr,
    },
    Select {
        condition: ClassicalExpr,
        then_expr: ClassicalExpr,
        else_expr: ClassicalExpr,
    },
    ExtractBit {
        value: ClassicalExpr,
        index: u32,
    },
    ExtractBits {
        value: ClassicalExpr,
        offset: u32,
        width: NonZeroU32,
    },
    Concat {
        parts: Box<[ClassicalExpr]>,
    },
    PackBits {
        bits: Box<[ClassicalExpr]>,
    },
}

Public node kind for inspecting a ClassicalExpr AST.

The variants mirror the expression builders on ClassicalExpr. External callers can pattern-match this enum through ClassicalExpr::kind, while expression construction should continue to use the typed builders.

Variants

Var(ClassicalVar)

Read a mutable circuit-local variable.

Value(ClassicalValue)

Read an immutable circuit-local SSA value.

BoolLiteral(bool)

Boolean literal.

BitLiteral(bool)

Single-bit literal.

UIntLiteral

Fixed-width unsigned integer literal.

Fields

width: NonZeroU32

Static integer width.

value: u128

Literal value, constrained to the declared width.

BitVecLiteral

Fixed-width ordered bit-vector literal.

Fields

width: NonZeroU32

Static bit-vector width.

value: u128

Packed little-endian literal value.

Unary

Unary operation.

Fields

op: ClassicalUnaryOp

Unary operator.

expr: ClassicalExpr

Operand expression.

Binary

Binary boolean or bit operation.

Fields

op: ClassicalBinaryOp

Binary operator.

lhs: ClassicalExpr

Left operand.

rhs: ClassicalExpr

Right operand.

Compare

Comparison producing a boolean result.

Fields

op: ClassicalCompareOp

Comparison operator.

lhs: ClassicalExpr

Left operand.

rhs: ClassicalExpr

Right operand.

Cast

Explicit conversion between classical types.

Fields

cast: ClassicalCast

Conversion operation.

expr: ClassicalExpr

Source expression.

Select

Conditional expression analogous to a typed ternary operator.

Fields

condition: ClassicalExpr

Boolean selection condition.

then_expr: ClassicalExpr

Value selected when the condition is true.

else_expr: ClassicalExpr

Value selected when the condition is false.

ExtractBit

Extract one bit from an integer or bit-vector expression.

Fields

value: ClassicalExpr

Source expression.

index: u32

Zero-based little-endian bit index.

ExtractBits

Extract a contiguous bit range.

Fields

value: ClassicalExpr

Source expression.

offset: u32

Zero-based little-endian starting offset.

width: NonZeroU32

Number of bits in the result.

Concat

Concatenate bit-vector expressions in the documented builder order.

Fields

parts: Box<[ClassicalExpr]>

Expressions being concatenated.

PackBits

Pack individual Bit expressions into a bit vector.

Fields

bits: Box<[ClassicalExpr]>

Bits in increasing little-endian bit-index order.

Trait Implementations

impl Clone for ClassicalExprKind

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 ClassicalExprKind

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

Formats the value using the given formatter.

impl Eq for ClassicalExprKind

impl Hash for ClassicalExprKind

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 ClassicalExprKind

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ClassicalExprKind