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 references(&self) -> Vec<Span<Arc<Path>>>

Get any references to other symbols present in this expression

Trait Implementations

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 Eq for ConstantExpr

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

Equality operator ==.

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

Inequality operator !=.

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