Enum JuliaStmt 

pub enum JuliaStmt {
    Expr(JuliaExpr),
    Assign(JuliaExpr, JuliaExpr),
    AugAssign(JuliaExpr, String, JuliaExpr),
    Local(String, Option<JuliaType>, Option<JuliaExpr>),
    Global(String),
    Const(String, Option<JuliaType>, JuliaExpr),
    Return(Option<JuliaExpr>),
    Break,
    Continue,
    If {
        cond: JuliaExpr,
        then_body: Vec<JuliaStmt>,
        elseif_branches: Vec<(JuliaExpr, Vec<JuliaStmt>)>,
        else_body: Option<Vec<JuliaStmt>>,
    },
    For {
        vars: Vec<String>,
        iter: JuliaExpr,
        body: Vec<JuliaStmt>,
    },
    While {
        cond: JuliaExpr,
        body: Vec<JuliaStmt>,
    },
    TryCatch {
        try_body: Vec<JuliaStmt>,
        catch_var: Option<String>,
        catch_body: Vec<JuliaStmt>,
        finally_body: Option<Vec<JuliaStmt>>,
    },
    FunctionDef(JuliaFunction),
    StructDef(JuliaStruct),
    AbstractTypeDef {
        name: String,
        type_params: Vec<String>,
        supertype: Option<String>,
    },
    PrimitiveTypeDef {
        name: String,
        bits: u32,
        supertype: Option<String>,
    },
    ModuleDef(JuliaModule),
    Using(Vec<String>),
    Import(String, Vec<String>),
    Export(Vec<String>),
    Include(String),
    MacroDef {
        name: String,
        params: Vec<String>,
        body: Vec<JuliaStmt>,
    },
    Comment(String),
    Blank,
}

Julia statement.

Variants

Expr(JuliaExpr)

Expression statement: expr

Assign(JuliaExpr, JuliaExpr)

Local assignment: x = expr

AugAssign(JuliaExpr, String, JuliaExpr)

Augmented assignment: x += expr

Local(String, Option<JuliaType>, Option<JuliaExpr>)

Local variable declaration: local x::T = expr

Global(String)

Global variable declaration: global x

Const(String, Option<JuliaType>, JuliaExpr)

Const declaration: const x = expr

Return(Option<JuliaExpr>)

Return statement: return expr

Break

Break statement: break

Continue

Continue statement: continue

If

If/elseif/else statement

Fields

cond: JuliaExpr

then_body: Vec<JuliaStmt>

elseif_branches: Vec<(JuliaExpr, Vec<JuliaStmt>)>

else_body: Option<Vec<JuliaStmt>>

For

For loop: for x in iter

Fields

vars: Vec<String>

iter: JuliaExpr

body: Vec<JuliaStmt>

While

While loop: while cond

Fields

cond: JuliaExpr

body: Vec<JuliaStmt>

TryCatch

Try/catch/finally block

Fields

try_body: Vec<JuliaStmt>

catch_var: Option<String>

catch_body: Vec<JuliaStmt>

finally_body: Option<Vec<JuliaStmt>>

FunctionDef(JuliaFunction)

Function definition (see JuliaFunction)

StructDef(JuliaStruct)

Struct definition (see JuliaStruct)

AbstractTypeDef

Abstract type definition: abstract type Foo <: Bar end

Fields

name: String

type_params: Vec<String>

supertype: Option<String>

PrimitiveTypeDef

Primitive type definition: primitive type Foo 64 end

Fields

name: String

bits: u32

supertype: Option<String>

ModuleDef(JuliaModule)

Module definition

Using(Vec<String>)

Using statement: using Module

Import(String, Vec<String>)

Import statement: import Module: sym1, sym2

Export(Vec<String>)

Export statement: export sym1, sym2

Include(String)

Include statement: include("file.jl")

MacroDef

Macro definition: macro name(args...) body end

Fields

name: String

params: Vec<String>

body: Vec<JuliaStmt>

Comment(String)

Line comment: # comment

Blank

Empty line

Trait Implementations

impl Clone for JuliaStmt

fn clone(&self) -> JuliaStmt

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for JuliaStmt

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

Formats the value using the given formatter.

impl PartialEq for JuliaStmt

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