Enum Expr 

pub enum Expr {
    Number(f64),
    Band(usize),
    Variable(String),
    Binary {
        left: Box<Expr>,
        op: BinaryOp,
        right: Box<Expr>,
        ty: Type,
    },
    Unary {
        op: UnaryOp,
        expr: Box<Expr>,
        ty: Type,
    },
    Call {
        name: String,
        args: Vec<Expr>,
        ty: Type,
    },
    Conditional {
        condition: Box<Expr>,
        then_expr: Box<Expr>,
        else_expr: Box<Expr>,
        ty: Type,
    },
    Block {
        statements: Vec<Statement>,
        result: Option<Box<Expr>>,
        ty: Type,
    },
    ForLoop {
        var: String,
        start: Box<Expr>,
        end: Box<Expr>,
        body: Box<Expr>,
        ty: Type,
    },
}

Expression node

Variants

Number(f64)

Number literal

Band(usize)

Band reference (e.g., B1, B2)

Variable(String)

Variable reference

Binary

Binary operation

Fields

left: Box<Expr>

op: BinaryOp

right: Box<Expr>

ty: Type

Unary

Unary operation

Fields

op: UnaryOp

expr: Box<Expr>

ty: Type

Call

Function call

Fields

name: String

args: Vec<Expr>

ty: Type

Conditional

Conditional expression: if cond then expr1 else expr2

Fields

condition: Box<Expr>

then_expr: Box<Expr>

else_expr: Box<Expr>

ty: Type

Block

Block expression: { stmts; expr }

Fields

statements: Vec<Statement>

result: Option<Box<Expr>>

ty: Type

ForLoop

For loop (for optimization/unrolling)

Fields

var: String

start: Box<Expr>

end: Box<Expr>

body: Box<Expr>

ty: Type

Implementations

impl Expr

pub fn get_type(&self) -> Type

Gets the type of this expression

pub fn set_type(&mut self, new_type: Type)

Sets the type of this expression

pub fn is_constant(&self) -> bool

Checks if this expression is constant

pub fn is_pure(&self) -> bool

Checks if this expression is pure (has no side effects)

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Expr

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Expr

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.