Enum Expr 

pub enum Expr {
    Int {
        value: BigInt,
        span: Span,
    },
    Float {
        value: f64,
        span: Span,
    },
    Str {
        value: String,
        span: Span,
    },
    Bool {
        value: bool,
        span: Span,
    },
    None {
        span: Span,
    },
    Ident {
        name: String,
        span: Span,
    },
    List {
        items: Vec<Expr>,
        span: Span,
    },
    Dict {
        entries: Vec<(Expr, Expr)>,
        span: Span,
    },
    Binary {
        op: BinOp,
        lhs: Box<Expr>,
        rhs: Box<Expr>,
        span: Span,
    },
    Unary {
        op: UnOp,
        operand: Box<Expr>,
        span: Span,
    },
    Call {
        callee: Box<Expr>,
        args: Vec<Expr>,
        kwargs: Vec<(String, Expr)>,
        span: Span,
    },
    Index {
        obj: Box<Expr>,
        index: Box<Expr>,
        span: Span,
    },
    Slice {
        obj: Box<Expr>,
        start: Option<Box<Expr>>,
        end: Option<Box<Expr>>,
        step: Option<Box<Expr>>,
        span: Span,
    },
    Ternary {
        cond: Box<Expr>,
        then: Box<Expr>,
        otherwise: Box<Expr>,
        span: Span,
    },
    Attr {
        obj: Box<Expr>,
        name: String,
        span: Span,
    },
    SuperCall {
        method: String,
        args: Vec<Expr>,
        span: Span,
    },
    StrInterp {
        parts: Vec<InterpPart>,
        span: Span,
    },
}

One expression.

Variants

Int

Fields

value: BigInt

The literal’s value at full width — arbitrary precision, so a literal larger than i64 survives to codegen.

span: Span

Float

Fields

value: f64

span: Span

Str

Fields

value: String

span: Span

Bool

Fields

value: bool

span: Span

None

Fields

span: Span

Ident

Fields

name: String

span: Span

List

Fields

items: Vec<Expr>

span: Span

Dict

Fields

entries: Vec<(Expr, Expr)>

span: Span

Binary

Fields

op: BinOp

lhs: Box<Expr>

rhs: Box<Expr>

span: Span

Unary

Fields

op: UnOp

operand: Box<Expr>

span: Span

Call

f(a, b, key = c) — positional args, then any keyword arguments as (name, value) pairs in source order. Keyword arguments are only accepted where the callee is known at compile time (docs/SYNTAX.md §6).

Fields

callee: Box<Expr>

args: Vec<Expr>

kwargs: Vec<(String, Expr)>

span: Span

Index

Fields

obj: Box<Expr>

index: Box<Expr>

span: Span

Slice

obj[start:end:step] — each bound is optional (None means the default end of that side), matching Python slice semantics.

Fields

obj: Box<Expr>

start: Option<Box<Expr>>

end: Option<Box<Expr>>

step: Option<Box<Expr>>

span: Span

Ternary

then if cond else otherwise — only the taken branch is evaluated.

Fields

cond: Box<Expr>

then: Box<Expr>

otherwise: Box<Expr>

span: Span

Attr

Fields

obj: Box<Expr>

name: String

span: Span

SuperCall

super.method(args) — call a method inherited from the enclosing class’s parent, resolved statically. Only valid inside a method of a class that has a parent (docs/SYNTAX.md §8).

Fields

method: String

args: Vec<Expr>

span: Span

StrInterp

Fields

parts: Vec<InterpPart>

span: Span

Implementations

impl Expr

pub fn span(&self) -> Span

The source span this expression starts at.

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Expr