Enum JuliaExpr 

pub enum JuliaExpr {
    IntLit(i64),
    UIntLit(u64),
    FloatLit(f64),
    BoolLit(bool),
    StringLit(String),
    CharLit(char),
    Nothing,
    Var(String),
    Field(Box<JuliaExpr>, String),
    Index(Box<JuliaExpr>, Vec<JuliaExpr>),
    Slice(Box<JuliaExpr>, Option<Box<JuliaExpr>>, Option<Box<JuliaExpr>>),
    Call(Box<JuliaExpr>, Vec<JuliaExpr>),
    CallKw(Box<JuliaExpr>, Vec<JuliaExpr>, Vec<(String, JuliaExpr)>),
    Broadcast(Box<JuliaExpr>, Vec<JuliaExpr>),
    BinOp(String, Box<JuliaExpr>, Box<JuliaExpr>),
    UnOp(String, Box<JuliaExpr>),
    CompareChain(Vec<JuliaExpr>, Vec<String>),
    ArrayLit(Vec<JuliaExpr>),
    MatrixLit(Vec<Vec<JuliaExpr>>),
    Range(Box<JuliaExpr>, Option<Box<JuliaExpr>>, Box<JuliaExpr>),
    TupleLit(Vec<JuliaExpr>),
    ArrayComp(Box<JuliaExpr>, Vec<(String, JuliaExpr)>, Option<Box<JuliaExpr>>),
    Generator(Box<JuliaExpr>, Vec<(String, JuliaExpr)>, Option<Box<JuliaExpr>>),
    DictComp(Box<JuliaExpr>, Box<JuliaExpr>, Vec<(String, JuliaExpr)>),
    Lambda(Vec<JuliaParam>, Box<JuliaExpr>),
    DoBlock(Box<JuliaExpr>, Vec<String>, Vec<JuliaStmt>),
    Ternary(Box<JuliaExpr>, Box<JuliaExpr>, Box<JuliaExpr>),
    TypeAssert(Box<JuliaExpr>, JuliaType),
    Convert(JuliaType, Box<JuliaExpr>),
    IsA(Box<JuliaExpr>, JuliaType),
    TypeOf(Box<JuliaExpr>),
    Macro(String, Vec<JuliaExpr>),
    Interpolated(Vec<JuliaStringPart>),
    Splat(Box<JuliaExpr>),
    NamedArg(String, Box<JuliaExpr>),
    Pair(Box<JuliaExpr>, Box<JuliaExpr>),
    Block(Vec<JuliaStmt>),
}

Julia expression AST node.

Variants

IntLit(i64)

Integer literal: 42

UIntLit(u64)

Unsigned integer literal: 0x2a

FloatLit(f64)

Float literal: 3.14

BoolLit(bool)

Boolean literal: true / false

StringLit(String)

String literal: "hello"

CharLit(char)

Char literal: 'a'

Nothing

Nothing literal: nothing

Var(String)

Variable reference: x

Field(Box<JuliaExpr>, String)

Field access: obj.field

Index(Box<JuliaExpr>, Vec<JuliaExpr>)

Index access: arr[i]

Slice(Box<JuliaExpr>, Option<Box<JuliaExpr>>, Option<Box<JuliaExpr>>)

Slice: arr[begin:end]

Call(Box<JuliaExpr>, Vec<JuliaExpr>)

Function call: f(args...)

CallKw(Box<JuliaExpr>, Vec<JuliaExpr>, Vec<(String, JuliaExpr)>)

Keyword arguments call: f(a; key=val, ...)

Broadcast(Box<JuliaExpr>, Vec<JuliaExpr>)

Broadcasting call: f.(args...)

BinOp(String, Box<JuliaExpr>, Box<JuliaExpr>)

Binary operation: a + b

UnOp(String, Box<JuliaExpr>)

Unary operation: -x

CompareChain(Vec<JuliaExpr>, Vec<String>)

Comparison chain: a < b <= c

ArrayLit(Vec<JuliaExpr>)

Array literal: [1, 2, 3]

MatrixLit(Vec<Vec<JuliaExpr>>)

Matrix literal (rows separated by semicolons): [1 2; 3 4]

Range(Box<JuliaExpr>, Option<Box<JuliaExpr>>, Box<JuliaExpr>)

Range: 1:10 or 1:2:10

TupleLit(Vec<JuliaExpr>)

Tuple: (a, b, c)

ArrayComp(Box<JuliaExpr>, Vec<(String, JuliaExpr)>, Option<Box<JuliaExpr>>)

Array comprehension: [f(x) for x in xs]

Generator(Box<JuliaExpr>, Vec<(String, JuliaExpr)>, Option<Box<JuliaExpr>>)

Generator expression: (f(x) for x in xs)

DictComp(Box<JuliaExpr>, Box<JuliaExpr>, Vec<(String, JuliaExpr)>)

Dict comprehension: Dict(k => v for (k,v) in pairs)

Lambda(Vec<JuliaParam>, Box<JuliaExpr>)

Anonymous function: x -> x + 1

DoBlock(Box<JuliaExpr>, Vec<String>, Vec<JuliaStmt>)

Short anonymous function with do block is represented as Lambda

Ternary(Box<JuliaExpr>, Box<JuliaExpr>, Box<JuliaExpr>)

Ternary: cond ? then : else

TypeAssert(Box<JuliaExpr>, JuliaType)

Type assertion: x::T

Convert(JuliaType, Box<JuliaExpr>)

Type conversion: convert(T, x)

IsA(Box<JuliaExpr>, JuliaType)

isa check: x isa T

TypeOf(Box<JuliaExpr>)

typeof call: typeof(x)

Macro(String, Vec<JuliaExpr>)

Macro call: @macro args...

Interpolated(Vec<JuliaStringPart>)

Interpolated string: "text $(expr) more"

Splat(Box<JuliaExpr>)

Splat: args...

NamedArg(String, Box<JuliaExpr>)

Named argument pair: key = value

Pair(Box<JuliaExpr>, Box<JuliaExpr>)

Pair (for Dict): k => v

Block(Vec<JuliaStmt>)

Block expression: begin ... end

Trait Implementations

impl Clone for JuliaExpr

fn clone(&self) -> JuliaExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for JuliaExpr

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

Formats the value using the given formatter.

impl PartialEq for JuliaExpr

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