Enum ConstantExpr 

#[repr(u8)]
pub enum ConstantExpr {
    Int(Span<IntValue>),
    Var(Span<Arc<Path>>),
    BinaryOp {
        span: SourceSpan,
        op: ConstantOp,
        lhs: Box<ConstantExpr>,
        rhs: Box<ConstantExpr>,
    },
    String(Ident),
    Word(Span<WordValue>),
    Hash(HashKind, Ident),
}

Represents a constant expression or value in Miden Assembly syntax.

Variants

Int(Span<IntValue>)

A literal [Felt] value.

Var(Span<Arc<Path>>)

A reference to another constant.

BinaryOp

An binary arithmetic operator.

Fields

span: SourceSpan

op: ConstantOp

lhs: Box<ConstantExpr>

rhs: Box<ConstantExpr>

String(Ident)

A plain spanned string.

Word(Span<WordValue>)

A literal [‘WordValue’].

Hash(HashKind, Ident)

A spanned string with a HashKind showing to which type of value the given string should be hashed.

Implementations

impl ConstantExpr

pub fn is_value(&self) -> bool

Returns true if this expression is already evaluated to a concrete value

pub fn expect_int(&self) -> IntValue

Unwrap an IntValue from this expression or panic.

This is used in places where we expect the expression to have been folded to an integer, otherwise a bug occurred.

pub fn expect_felt(&self) -> Felt

Unwrap a [Felt] value from this expression or panic.

This is used in places where we expect the expression to have been folded to a felt value, otherwise a bug occurred.

pub fn expect_string(&self) -> Arc<str>

Unwrap a Arc<str> value from this expression or panic.

This is used in places where we expect the expression to have been folded to a string value, otherwise a bug occurred.

pub fn expect_value(&self) -> ConstantValue

Unwrap a ConstantValue from this expression or panic.

This is used in places where we expect the expression to have been folded to a concrete value, otherwise a bug occurred.

pub fn into_value(self) -> Result<ConstantValue, ConstantExpr>

Try to convert this expression into a ConstantValue, if the expression is a value.

Returns Err if the expression cannot be represented as a ConstantValue.

pub fn as_value(&self) -> Option<ConstantValue>

Get the ConstantValue representation of this expression, if it is a value.

Returns None if the expression cannot be represented as a ConstantValue.

pub fn try_fold(self) -> Result<ConstantExpr, ParsingError>

Attempt to fold to a single value.

This will only succeed if the expression has no references to other constants.

Errors

Returns an error if an invalid expression is found while folding, such as division by zero.

pub fn references(&self) -> Vec<Span<Arc<Path>>>

Get any references to other symbols present in this expression

Trait Implementations

impl Arbitrary for ConstantExpr

Available on crate feature arbitrary only.

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = BoxedStrategy<ConstantExpr>

The type of Strategy used to generate values of type Self.

fn arbitrary_with( _args: <ConstantExpr as Arbitrary>::Parameters, ) -> <ConstantExpr as Arbitrary>::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for ConstantExpr

fn clone(&self) -> ConstantExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConstantExpr

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

Formats the value using the given formatter.

impl From<ConstantValue> for ConstantExpr

fn from(value: ConstantValue) -> ConstantExpr

Converts to this type from the input type.

impl Hash for ConstantExpr

fn hash<H>(&self, state: &mut H)

where H: Hasher,

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 ConstantExpr

fn eq(&self, other: &ConstantExpr) -> 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 PrettyPrint for ConstantExpr

fn render(&self) -> Document

The core of the [PrettyPrint] functionality.

fn to_pretty_string(&self) -> String

Produce a String containing the results of pretty-printing this object.

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

Pretty-print this object to the given core::fmt::Formatter.

impl Spanned for ConstantExpr

fn span(&self) -> SourceSpan

impl Eq for ConstantExpr