Enum Stmt 

pub enum Stmt {
    Expr(Expr),
    Let {
        name: String,
        init: Option<Expr>,
        mutable: bool,
    },
    Block(Vec<Stmt>),
    If {
        test: Expr,
        consequent: Box<Stmt>,
        alternate: Option<Box<Stmt>>,
    },
    While {
        test: Expr,
        body: Box<Stmt>,
    },
    For {
        init: Option<Box<Stmt>>,
        test: Option<Expr>,
        update: Option<Expr>,
        body: Box<Stmt>,
    },
    ForIn {
        variable: String,
        iterable: Expr,
        body: Box<Stmt>,
    },
    Return(Option<Expr>),
    Break,
    Continue,
    TryCatch {
        body: Box<Stmt>,
        catch_param: Option<String>,
        catch_body: Option<Box<Stmt>>,
        finally_body: Option<Box<Stmt>>,
    },
    Function(Function),
}

A statement (doesn’t produce a value directly).

Variants

Expr(Expr)

Expression statement: expr;.

Let

Variable declaration: let name = init or const name = init.

Fields

name: String

init: Option<Expr>

mutable: bool

Block(Vec<Stmt>)

Block: { stmts... }.

If

If statement: if (test) consequent else alternate.

Fields

test: Expr

consequent: Box<Stmt>

alternate: Option<Box<Stmt>>

While

While loop: while (test) body.

Fields

test: Expr

body: Box<Stmt>

For

For loop: for (init; test; update) body.

Fields

init: Option<Box<Stmt>>

test: Option<Expr>

update: Option<Expr>

body: Box<Stmt>

ForIn

For-in/for-of loop: for (variable in/of iterable) body.

Fields

variable: String

iterable: Expr

body: Box<Stmt>

Return(Option<Expr>)

Return statement: return expr.

Break

Break statement.

Continue

Continue statement.

TryCatch

Try/catch/finally statement.

Fields

body: Box<Stmt>

catch_param: Option<String>

catch_body: Option<Box<Stmt>>

finally_body: Option<Box<Stmt>>

Function(Function)

Function declaration.

Implementations

impl Stmt

pub fn expr(e: Expr) -> Self

pub fn let_decl(name: impl Into<String>, init: Option<Expr>) -> Self

pub fn const_decl(name: impl Into<String>, init: Expr) -> Self

pub fn block(stmts: Vec<Stmt>) -> Self

pub fn if_stmt(test: Expr, consequent: Stmt, alternate: Option<Stmt>) -> Self

pub fn while_loop(test: Expr, body: Stmt) -> Self

pub fn for_loop( init: Option<Stmt>, test: Option<Expr>, update: Option<Expr>, body: Stmt, ) -> Self

pub fn for_in(variable: impl Into<String>, iterable: Expr, body: Stmt) -> Self

pub fn return_stmt(expr: Option<Expr>) -> Self

pub fn break_stmt() -> Self

pub fn continue_stmt() -> Self

pub fn try_catch( body: Stmt, catch_param: Option<String>, catch_body: Option<Stmt>, finally_body: Option<Stmt>, ) -> Self

pub fn function(f: Function) -> Self

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<'de> Deserialize<'de> for Stmt

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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 Serialize for Stmt

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructureEq for Stmt

fn structure_eq(&self, other: &Self) -> bool

Compare two values for structural equality.

impl StructuralPartialEq for Stmt