Enum ClassicalExpr 

pub enum ClassicalExpr {
    In(u32),
    Const(bool),
    Not(Box<ClassicalExpr>),
    Xor(Box<[ClassicalExpr]>),
    And(Box<[ClassicalExpr]>),
    Or(Box<[ClassicalExpr]>),
    Select(Box<[ClassicalExpr; 3]>),
    Parity {
        inputs: Box<[u32]>,
        constant: bool,
    },
}

Combinational logic over a classical node’s incoming Value edges.

ClassicalExpr::In reads the edge whose slot equals its index (SSA-by-slot): the slot is carried on the edge, so the binding survives edge reordering under edits rather than depending on iteration order.

Variants

In(u32)

Read one incoming edge slot.

Const(bool)

A compile-time-constant bit — an input-less producer. Carries a deterministic feedback sign (constant-sign folds to no op).

Not(Box<ClassicalExpr>)

Boolean negation.

Xor(Box<[ClassicalExpr]>)

Ordered parity operands; the empty parity is false.

And(Box<[ClassicalExpr]>)

Ordered conjunction operands; the empty conjunction is true.

Or(Box<[ClassicalExpr]>)

Ordered disjunction operands; the empty disjunction is false.

Select(Box<[ClassicalExpr; 3]>)

[condition, when_false, when_true]. All three operands must be known, including the unselected value; this is combinational dataflow (SEM-EXPR).

Parity

Affine parity of ordered input slots and a constant XOR term. Repeated slots stay present: every input must be known even when its Boolean contributions cancel (SEM-EXPR). No expression nodes per slot.

Fields

inputs: Box<[u32]>

Ordered input slots.

constant: bool

Constant XOR term.

Implementations

impl ClassicalExpr

pub fn parity(inputs: impl IntoIterator<Item = u32>, constant: bool) -> Self

Build an affine parity, retaining input order and multiplicity.

pub fn xor(operands: impl IntoIterator<Item = Self>) -> Self

Build a parity list, collapsing empty and singleton lists. Preserves operand order, duplicates, and nested expressions.

Panics

Panics only if the collected operand count changes before extraction.

pub fn select(condition: Self, when_false: Self, when_true: Self) -> Self

Select a value with explicit false/true operand order (SEM-EXPR). Literal branches use smaller operators without dropping unknown inputs.

pub fn operands(&self) -> &[Self]

Direct expression children in evaluation order. Compact Self::Parity stores slots directly; use Self::for_each_input to visit all inputs.

pub fn eval(&self, input: &mut impl FnMut(u32) -> Option<bool>) -> Option<bool>

Fold the expression over three-valued inputs: None (an input that is unevaluable in the caller’s context) propagates. The reference evaluator every consumer shares.

pub fn for_each_input(&self, f: &mut impl FnMut(u32))

Visit every In(slot) leaf, left to right.

pub fn is_linear(&self) -> bool

Whether the expression is XOR-expressible (In/Const/Not/Xor/Parity only). A static backend folds a linear condition into OBSERVABLE_INCLUDE; a nonlinear (And/Or/Select) one needs a dynamic backend.

Trait Implementations

impl Clone for ClassicalExpr

fn clone(&self) -> ClassicalExpr

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<'de> Deserialize<'de> for ClassicalExpr

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ClassicalExpr

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

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ClassicalExpr

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ClassicalExpr