Struct IRBexpr 

pub struct IRBexpr<A>(/* private fields */);

Represents boolean expressions over some arithmetic expression type A.

Implementations

impl<T> IRBexpr<T>

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

Transforms the inner expression into a different type.

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

Transforms the inner expression into a different type without moving the struct.

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

Transforms the inner expression into a different type, potentially failing.

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

Transforms the inner expression in place instead of returning a new expression.

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

Tries to transform the inner expression in place instead of returning a new expression.

pub fn det(expr: T) -> Self

Creates a expression that indicates the backend must prove deterministic.

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 implies(self, rhs: Self) -> Self

Creates an implication expression.

pub fn iff(self, rhs: Self) -> Self

Creates a double implication expression.

pub fn and(self, rhs: Self) -> Self

Creates a logical AND.

pub fn and_many(exprs: impl IntoIterator<Item = Self>) -> Self

Creates a logical AND from a sequence of expressions.

pub fn or(self, rhs: Self) -> Self

Creates a logical OR.

pub fn or_many(exprs: impl IntoIterator<Item = Self>) -> Self

Creates a logical OR from a sequence of expressions.

pub fn with<O>(self, other: O) -> IRBexpr<(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) -> IRBexpr<(O, T)>

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

Trait Implementations

impl<A> AsMut<IRBexpr<A>> for IRConstBexpr<A>

fn as_mut(&mut self) -> &mut IRBexpr<A>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<A> AsRef<IRBexpr<A>> for IRConstBexpr<A>

fn as_ref(&self) -> &IRBexpr<A>

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> BitAnd for IRBexpr<T>

type Output = IRBexpr<T>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T> BitOr for IRBexpr<T>

type Output = IRBexpr<T>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<A> Borrow<IRBexpr<A>> for IRConstBexpr<A>

fn borrow(&self) -> &IRBexpr<A>

Immutably borrows from an owned value.

impl<A> BorrowMut<IRBexpr<A>> for IRConstBexpr<A>

fn borrow_mut(&mut self) -> &mut IRBexpr<A>

Mutably borrows from an owned value.

impl Canonicalize for IRBexpr<IRAexpr>

fn canonicalize(&mut self)

Matches the expressions 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 IRBexpr<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 IRBexpr<T>

where T: ConstantFolding + Debug, T::T: Eq + Ord,

fn const_value(&self) -> Option<bool>

Returns Some(true) or Some(false) if the expression is constant, None otherwise.

type T = bool

Object’s type for constants.

type Error = <T as ConstantFolding>::Error

Error type.

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

Folds the object in-place.

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

where Self: Sized,

Moves the object after folding it.

impl<A: Debug> Debug for IRBexpr<A>

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

Formats the value using the given formatter.

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

where SymbolicEqv: EqvRelation<L, R>,

IRBexprImpl transitively inherits the symbolic equivalence relation.

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

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

impl<T: Evaluate<ExprProperties>> Evaluate<ExprProperties> for IRBexpr<T>

fn evaluate(&self) -> ExprProperties

Evaluate the IR object and return a result.

impl<A> From<IRConstBexpr<A>> for IRBexpr<A>

fn from(value: IRConstBexpr<A>) -> Self

Converts to this type from the input type.

impl<T> From<bool> for IRBexpr<T>

fn from(value: bool) -> Self

Converts to this type from the input type.

impl<T: IRPrintable> IRPrintable for IRBexpr<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: LowerableExpr> LowerableExpr for IRBexpr<A>

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

where L: ExprLowering + ?Sized,

Transforms the value into an expression.

impl<T> Not for IRBexpr<T>

type Output = IRBexpr<T>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T: PartialEq> PartialEq for IRBexpr<T>

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

Tests for self and other values to be equal, and is used by ==.

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<A> TryFrom<IRBexpr<A>> for IRConstBexpr<A>

where IRBexpr<A>: Evaluate<ExprProperties>,

type Error = NonConstIRBexprError

The type returned in the event of a conversion error.

fn try_from(value: IRBexpr<A>) -> Result<Self, Self::Error>

Performs the conversion.