Enum Stmt 

pub enum Stmt {
    LocalDecl {
        name: String,
        init: Option<Expr>,
    },
    LocalMulti {
        names: Vec<String>,
        inits: Vec<Expr>,
    },
    Assign {
        target: Vec<Expr>,
        value: Vec<Expr>,
    },
    CompoundAssign {
        target: Expr,
        op: BinOp,
        value: Expr,
    },
    Call(Expr),
    Do(Vec<Stmt>),
    While {
        cond: Expr,
        body: Vec<Stmt>,
    },
    RepeatUntil {
        body: Vec<Stmt>,
        cond: Expr,
    },
    If {
        cond: Expr,
        then_body: Vec<Stmt>,
        elseif_branches: Vec<(Expr, Vec<Stmt>)>,
        else_body: Option<Vec<Stmt>>,
    },
    NumericFor {
        var: String,
        start: Expr,
        limit: Expr,
        step: Option<Expr>,
        body: Vec<Stmt>,
    },
    GenericFor {
        vars: Vec<String>,
        iter: Vec<Expr>,
        body: Vec<Stmt>,
    },
    FuncDecl {
        name: Vec<String>,
        params: Vec<String>,
        vararg: bool,
        body: Vec<Stmt>,
    },
    LocalFunc {
        name: String,
        params: Vec<String>,
        vararg: bool,
        body: Vec<Stmt>,
    },
    Return(Vec<Expr>),
    Break,
    Continue,
    Match {
        expr: Expr,
        arms: Vec<MatchArm>,
    },
    Import {
        path: String,
        alias: Option<String>,
    },
    Export(String),
    Expr(Expr),
}

Variants

LocalDecl

local name [= expr]

Fields

name: String

init: Option<Expr>

LocalMulti

local name1, name2 = expr1, expr2

Fields

names: Vec<String>

inits: Vec<Expr>

Assign

target = expr

Fields

target: Vec<Expr>

value: Vec<Expr>

CompoundAssign

compound assign: target op= expr

Fields

target: Expr

op: BinOp

value: Expr

Call(Expr)

function call statement

Do(Vec<Stmt>)

do … end

While

while cond do … end

Fields

cond: Expr

body: Vec<Stmt>

RepeatUntil

repeat … until cond

Fields

body: Vec<Stmt>

cond: Expr

If

if cond then … [elseif …] [else …] end

Fields

cond: Expr

then_body: Vec<Stmt>

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

else_body: Option<Vec<Stmt>>

NumericFor

numeric for: for i = start, limit[, step] do … end

Fields

var: String

start: Expr

limit: Expr

step: Option<Expr>

body: Vec<Stmt>

GenericFor

generic for: for names in expr do … end

Fields

vars: Vec<String>

iter: Vec<Expr>

body: Vec<Stmt>

FuncDecl

function name(params) body end

Fields

name: Vec<String>

params: Vec<String>

vararg: bool

body: Vec<Stmt>

LocalFunc

local function name(params) body end

Fields

name: String

params: Vec<String>

vararg: bool

body: Vec<Stmt>

Return(Vec<Expr>)

return [expr, …]

Break

break

Continue

continue

Match

match expr { case pattern => body }

Fields

expr: Expr

arms: Vec<MatchArm>

Import

import “module” [as name]

Fields

path: String

alias: Option<String>

Export(String)

export name

Expr(Expr)

expr (standalone expression — error unless call)

Trait Implementations

impl Clone for Stmt

fn clone(&self) -> Stmt

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Stmt

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

Formats the value using the given formatter.

impl PartialEq for Stmt

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