Struct IRStmt 

pub struct IRStmt<T>(/* private fields */);

IR for operations that occur in the main circuit.

Implementations

impl<T> IRStmt<T>

pub fn call( callee: impl AsRef<str>, inputs: impl IntoIterator<Item = T>, outputs: impl IntoIterator<Item = Slot>, ) -> Self

Creates a call to another module.

pub fn post_cond(cond: IRBexpr<T>) -> Self

Creates a post condition formula.

pub fn constraint(op: CmpOp, lhs: T, rhs: T) -> Self

Creates a constraint between two expressions.

pub fn eq(lhs: T, rhs: T) -> Self

Creates a constraint with CmpOp::Eq between two expressions.

pub fn lt(lhs: T, rhs: T) -> Self

Creates a constraint with CmpOp::Lt between two expressions.

pub fn le(lhs: T, rhs: T) -> Self

Creates a constraint with CmpOp::Le between two expressions.

pub fn gt(lhs: T, rhs: T) -> Self

Creates a constraint with CmpOp::Gt between two expressions.

pub fn ge(lhs: T, rhs: T) -> Self

Creates a constraint with CmpOp::Ge between two expressions.

pub fn comment(s: impl AsRef<str>) -> Self

Creates a text comment.

pub fn assume_deterministic(f: impl Into<Slot>) -> Self

Indicates that the Slot must be assumed deterministic by the backend.

pub fn assert(cond: IRBexpr<T>) -> Self

Creates an assertion in the circuit.

pub fn seq<I>(stmts: impl IntoIterator<Item = IRStmt<I>>) -> Self

where I: Into<T>,

Creates a statement that is a sequence of other statements.

pub fn empty() -> Self

Creates an empty statement.

pub fn is_empty(&self) -> bool

Returns true if the statement is empty.

pub fn with_comment(self, comment: String) -> Self

Prepends a comment to the statement.

pub fn map<O>(self, f: &mut impl FnMut(T) -> O) -> IRStmt<O>

Transforms the inner expression type into another.

pub fn with<O>(self, other: O) -> IRStmt<(O, T)>

where O: Clone,

Maps the statement’s inner type to a tuple with the passed value.

pub fn with_fn<O>(self, other: impl Fn() -> O) -> IRStmt<(O, T)>

Maps the statement’s inner type to a tuple with the result of the closure.

pub fn into<O>(self) -> IRStmt<O>

where O: From<T> + Evaluate<ExprProperties>,

Transforms the inner expression type using Into::into.

pub fn from<O>(value: IRStmt<O>) -> Self

where O: Into<T>,

Transforms the inner expression type using From::from.

pub fn then(self, other: impl Into<Self>) -> Self

Appends the given statement to the current one.

pub fn map_into<O>(&self, f: &mut impl FnMut(&T) -> O) -> IRStmt<O>

Transforms the inner expression type into another, without moving.

pub fn try_map<O, E>( self, f: &mut impl FnMut(T) -> Result<O, E>, ) -> Result<IRStmt<O>, E>

Tries to transform the inner expression type into another.

pub fn map_inplace(&mut self, f: &mut impl FnMut(&mut T))

Modifies the inner expression type in place.

pub fn try_map_inplace<E>( &mut self, f: &mut impl FnMut(&mut T) -> Result<(), E>, ) -> Result<(), E>

Tries to modify the inner expression type in place.

pub fn map_slot_inplace(&mut self, f: &mut impl FnMut(&mut Slot))

Modifies the inner slots in place.

pub fn try_map_slot_inplace<E>( &mut self, f: &mut impl FnMut(&mut Slot) -> Result<(), E>, ) -> Result<(), E>

Tries to modify the inner slots n place.

pub fn iter(&self) -> IRStmtRefIter<'_, T>

Returns an iterator of references to the statements.

pub fn iter_mut(&mut self) -> IRStmtRefMutIter<'_, T>

Returns an iterator of mutable references to the statements.

pub fn propagate_meta(&mut self)

Propagates the metadata of this statement to the inner statements.

Trait Implementations

impl Canonicalize for IRStmt<IRAexpr>

fn canonicalize(&mut self)

Matches the statements against a series of known patterns and applies rewrites if able to.

fn canonicalized(self) -> Self

where Self: Sized,

Transforms the object into its canonical version.

impl<T: Clone> Clone for IRStmt<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> ConstantFolding for IRStmt<T>

where T: ConstantFolding + Debug + Clone, Error: From<T::Error>, T::T: Eq + Ord,

fn constant_fold(&mut self) -> Result<(), Error>

Folds the statements if the expressions are constant. If a assert-like statement folds into a tautology (i.e. (= 0 0 )) gets removed. If it folds into a unsatisfiable proposition the method returns an error.

type Error = Error

Error type.

type T = ()

Object’s type for constants.

fn constant_folded(self) -> Result<Self, Self::Error>

where Self: Sized,

Moves the object after folding it.

fn const_value(&self) -> Option<Self::T>

May return the object as a constant value.

impl<T: Debug> Debug for IRStmt<T>

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

Formats the value using the given formatter.

impl<T> Default for IRStmt<T>

fn default() -> Self

Returns the “default value” for a type.

impl<L, R> EqvRelation<IRStmt<L>, IRStmt<R>> for SymbolicEqv

where SymbolicEqv: EqvRelation<L, R> + EqvRelation<Slot, Slot>,

IRStmt transilitively inherits the SymbolicEqv equivalence relation.

fn equivalent(lhs: &IRStmt<L>, rhs: &IRStmt<R>) -> bool

Two statements are equivalent if they are structurally equal and their inner entities are equivalent.

impl<I> FromIterator<IRStmt<I>> for IRStmt<I>

fn from_iter<T: IntoIterator<Item = IRStmt<I>>>(iter: T) -> Self

Creates a value from an iterator.

impl<T> HasMeta for IRStmt<T>

fn meta(&self) -> &Meta

Returns a reference to the metadata.

fn meta_mut(&mut self) -> &mut Meta

Returns a mutable reference to the metadata.

impl<T: IRPrintable> IRPrintable for IRStmt<T>

fn fmt(&self, ctx: &mut IRPrinterCtx<'_, '_>) -> Result

Format the IR object using the given context.

fn depth(&self) -> usize

Computes the depth of the IR tree to give hints to the printer.

impl<'a, T> IntoIterator for &'a IRStmt<T>

type Item = &'a IRStmt<T>

The type of the elements being iterated over.

type IntoIter = IRStmtRefIter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut IRStmt<T>

type Item = &'a mut IRStmt<T>

The type of the elements being iterated over.

type IntoIter = IRStmtRefMutIter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> IntoIterator for IRStmt<T>

type Item = IRStmt<T>

The type of the elements being iterated over.

type IntoIter = IRStmtIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: LowerableExpr> LowerableStmt for IRStmt<T>

where CondBlock<T>: LowerableStmt,

fn lower<L>(self, l: &L) -> Result<()>

where L: Lowering + ?Sized,

Emits a statement from the value.

impl<T: PartialEq> PartialEq for IRStmt<T>

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

Equality is defined by the sequence of statements regardless of how they are structured inside.

For example: Seq([a, Seq([b, c])]) == Seq([a, b, c]) a == Seq([a])

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<T, D> Validatable for IRStmt<T>

where IRConstBexpr<T>: Validatable<Diagnostic = D, Context = ()>, D: Diagnostic,

type Diagnostic = D

The type used to represent diagnostics.

type Context = ()

Context necessary for validating the IR.

fn validate_with_context( &self, _: &Self::Context, ) -> Result<Vec<Self::Diagnostic>, Vec<Self::Diagnostic>>

Performs validation checks, returning either Ok with a list of non-error diagnostics or Err with a list of all the diagnostics.

fn validate(&self) -> Result<Vec<Self::Diagnostic>, Vec<Self::Diagnostic>>

where Self::Context: Default,

Performs validation checks, returning either Ok with a list of non-error diagnostics or Err with a list of all the diagnostics.