Enum rhai::Stmt

pub enum Stmt {
    Noop(Position),
    IfThenElse(Box<(Expr, Stmt, Option<Stmt>, Position)>),
    While(Box<(Expr, Stmt, Position)>),
    Loop(Box<(Stmt, Position)>),
    For(Box<(String, Expr, Stmt, Position)>),
    Let(Box<((String, Position), Option<Expr>, Position)>),
    Const(Box<((String, Position), Option<Expr>, Position)>),
    Block(Box<(StaticVec<Stmt>, Position)>),
    Expr(Box<Expr>),
    Continue(Position),
    Break(Position),
    ReturnWithVal(Box<((ReturnType, Position), Option<Expr>, Position)>),
    Import(Box<(Expr, Option<(ImmutableString, Position)>, Position)>),
    Export(Box<(StaticVec<((String, Position), Option<(String, Position)>)>, Position)>),
    Share(Box<(String, Position)>),
}

[INTERNALS] A Rhai statement. Exported under the internals feature only.

Each variant is at most one pointer in size (for speed), with everything being allocated together in one single tuple.

Variants

Noop(Position)

Tuple Fields

0: Position

No-op.

IfThenElse(Box<(Expr, Stmt, Option<Stmt>, Position)>)

Tuple Fields

0: Box<(Expr, Stmt, Option<Stmt>, Position)>

if expr { stmt } else { stmt }

While(Box<(Expr, Stmt, Position)>)

Tuple Fields

0: Box<(Expr, Stmt, Position)>

while expr { stmt }

Loop(Box<(Stmt, Position)>)

Tuple Fields

0: Box<(Stmt, Position)>

loop { stmt }

For(Box<(String, Expr, Stmt, Position)>)

Tuple Fields

0: Box<(String, Expr, Stmt, Position)>

for id in expr { stmt }

Let(Box<((String, Position), Option<Expr>, Position)>)

Tuple Fields

0: Box<((String, Position), Option<Expr>, Position)>

let id = expr

Const(Box<((String, Position), Option<Expr>, Position)>)

Tuple Fields

0: Box<((String, Position), Option<Expr>, Position)>

const id = expr

Block(Box<(StaticVec<Stmt>, Position)>)

Tuple Fields

0: Box<(StaticVec<Stmt>, Position)>

{ stmt; … }

Expr(Box<Expr>)

Tuple Fields

0: Box<Expr>

expr

Continue(Position)

Tuple Fields

0: Position

continue

Break(Position)

Tuple Fields

0: Position

break

ReturnWithVal(Box<((ReturnType, Position), Option<Expr>, Position)>)

Tuple Fields

0: Box<((ReturnType, Position), Option<Expr>, Position)>

return/throw

Import(Box<(Expr, Option<(ImmutableString, Position)>, Position)>)

Tuple Fields

0: Box<(Expr, Option<(ImmutableString, Position)>, Position)>

import expr as module

Export(Box<(StaticVec<((String, Position), Option<(String, Position)>)>, Position)>)

Tuple Fields

0: Box<(StaticVec<((String, Position), Option<(String, Position)>)>, Position)>

expr id as name, …

Share(Box<(String, Position)>)

Tuple Fields

0: Box<(String, Position)>

Convert a variable to shared.

Implementations

impl Stmt

pub fn position(&self) -> Position

Get the Position of this statement.

pub fn set_position(&mut self, new_pos: Position) -> &mut Self

Override the Position of this statement.

pub fn is_self_terminated(&self) -> bool

Is this statement self-terminated (i.e. no need for a semicolon terminator)?

pub fn is_pure(&self) -> bool

Is this statement pure?

Trait Implementations

impl Clone for Stmt

fn clone(&self) -> Stmt

Returns a copy 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 Default for Stmt

fn default() -> Self

Returns the “default value” for a type.

impl Hash for Stmt

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.