Enum ConstantExpr 

pub enum ConstantExpr {
    Int(Span<IntValue>),
    Var(Ident),
    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(Ident)

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 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>

pub fn try_fold(self) -> Result<Self, 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.

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

Formats the value using the given formatter.

impl Hash for ConstantExpr

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 ConstantExpr

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 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