Enum Expr 

pub enum Expr {
    Int(i64, Span),
    Float(f64, Span),
    Str(String, Span),
    Bool(bool, Span),
    Null(Span),
    Ident(String, Span),
    Binary {
        left: Box<Expr>,
        op: BinOp,
        right: Box<Expr>,
        span: Span,
    },
    Unary {
        op: UnaryOp,
        operand: Box<Expr>,
        span: Span,
    },
    Call {
        func: String,
        args: Vec<Arg>,
        span: Span,
    },
    QualifiedCall {
        path: Vec<String>,
        args: Vec<Arg>,
        span: Span,
    },
    Member {
        object: Box<Expr>,
        field: String,
        span: Span,
    },
    Index {
        object: Box<Expr>,
        index: Box<Expr>,
        end: Option<Box<Expr>>,
        span: Span,
    },
    List(Vec<Expr>, Span),
    Dict(Vec<(String, Expr)>, Span),
    Paren(Box<Expr>, Span),
    IfExpr {
        cond: Box<Expr>,
        then_branch: Box<Expr>,
        else_branch: Option<Box<Expr>>,
        span: Span,
    },
    RepeatExpr {
        count: Box<Expr>,
        body: Box<Expr>,
        span: Span,
    },
    Closure {
        params: Vec<String>,
        body: Box<Expr>,
        span: Span,
    },
}

Variants

Int(i64, Span)

Integer literal: 42

Float(f64, Span)

Float literal: 3.14

Str(String, Span)

String literal: "hello"

Bool(bool, Span)

Boolean: true, false

Null(Span)

Null: null

Ident(String, Span)

Identifier: x, Batch

Binary

Binary expression: a + b

Fields

left: Box<Expr>

op: BinOp

right: Box<Expr>

span: Span

Unary

Unary expression: -x, !cond

Fields

op: UnaryOp

operand: Box<Expr>

span: Span

Call

Function call: matmul(x, w)

Fields

func: String

args: Vec<Arg>

span: Span

QualifiedCall

Qualified call: module.func(args) or mod::func(args)

Fields

path: Vec<String>

args: Vec<Arg>

span: Span

Member

Member access: x.shape

Fields

object: Box<Expr>

field: String

span: Span

Index

Index access: x[0] or x[1:3]

Fields

object: Box<Expr>

index: Box<Expr>

end: Option<Box<Expr>>

span: Span

List(Vec<Expr>, Span)

List expression: [1, 2, 3]

Dict(Vec<(String, Expr)>, Span)

Dict expression: { key: value, ... }

Paren(Box<Expr>, Span)

Parenthesized: (expr)

IfExpr

Block operation — if

Fields

cond: Box<Expr>

then_branch: Box<Expr>

else_branch: Option<Box<Expr>>

span: Span

RepeatExpr

Block operation — repeat

Fields

count: Box<Expr>

body: Box<Expr>

span: Span

Closure

Closure: |a, b| { expr }

Fields

params: Vec<String>

body: Box<Expr>

span: Span

Implementations

impl Expr

pub fn span(&self) -> Span

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<(), Error>

Formats the value using the given formatter.