Enum Expr 

pub enum Expr {
    Number(f64),
    BigInteger(String),
    String(String),
    Boolean(bool),
    Null,
    Identifier(String),
    Binary {
        left: Box<Expr>,
        op: BinOp,
        right: Box<Expr>,
    },
    Unary {
        op: UnaryOp,
        expr: Box<Expr>,
    },
    Call {
        func: Box<Expr>,
        args: Vec<Expr>,
    },
    Array(Vec<Expr>),
    Dict(Vec<(String, Expr)>),
    Index {
        object: Box<Expr>,
        index: Box<Expr>,
    },
    If {
        condition: Box<Expr>,
        then_branch: Vec<Stmt>,
        elif_branches: Vec<(Expr, Vec<Stmt>)>,
        else_branch: Option<Vec<Stmt>>,
    },
    Lambda {
        params: Vec<String>,
        body: Vec<Stmt>,
    },
}

Expressions - things that evaluate to values

Variants

Number(f64)

BigInteger(String)

String(String)

Boolean(bool)

Null

Identifier(String)

Binary

Fields

left: Box<Expr>

op: BinOp

right: Box<Expr>

Unary

Fields

op: UnaryOp

expr: Box<Expr>

Call

Fields

func: Box<Expr>

args: Vec<Expr>

Array(Vec<Expr>)

Dict(Vec<(String, Expr)>)

Index

Fields

object: Box<Expr>

index: Box<Expr>

If

Fields

condition: Box<Expr>

then_branch: Vec<Stmt>

elif_branches: Vec<(Expr, Vec<Stmt>)>

else_branch: Option<Vec<Stmt>>

Lambda

Fields

params: Vec<String>

body: Vec<Stmt>

Implementations

impl Expr

pub fn binary(left: Expr, op: BinOp, right: Expr) -> Self

Helper to create a binary expression

pub fn unary(op: UnaryOp, expr: Expr) -> Self

Helper to create a unary expression

pub fn call(func: Expr, args: Vec<Expr>) -> Self

Helper to create a function call

pub fn index(object: Expr, index: Expr) -> Self

Helper to create an index expression

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 PartialEq for Expr

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