Enum rhai::Stmt [−][src]
pub enum Stmt {
Show 18 variants
Noop(Position),
If(Expr, Box<(StmtBlock, StmtBlock)>, Position),
Switch(Expr, Box<(BTreeMap<u64, Box<(Option<Expr>, StmtBlock)>>, StmtBlock)>, Position),
While(Expr, Box<StmtBlock>, Position),
Do(Box<StmtBlock>, Expr, OptionFlags, Position),
For(Expr, Box<(Ident, Option<Ident>, StmtBlock)>, Position),
Var(Expr, Box<Ident>, OptionFlags, Position),
Assignment(Box<(Expr, Option<OpAssignment<'static>>, Expr)>, Position),
FnCall(Box<FnCallExpr>, Position),
Block(Box<[Stmt]>, Position),
TryCatch(Box<(StmtBlock, Option<Ident>, StmtBlock)>, Position),
Expr(Expr),
Continue(Position),
Break(Position),
Return(ReturnType, Option<Expr>, Position),
Import(Expr, Option<Box<Ident>>, Position),
Export(Box<[(Ident, Ident)]>, Position),
Share(Identifier),
}
Expand description
(internals) A statement.
Exported under the internals
feature only.
Volatile Data Structure
This type is volatile and may change.
Variants
Noop(Position)
No-op.
Tuple Fields of Noop
0: Position
if
expr {
stmt }
else
{
stmt }
switch
expr if
condition {
literal or _ =>
stmt ,
… }
Tuple Fields of Switch
while
expr {
stmt }
| loop
{
stmt }
If the guard expression is UNIT
, then it is a loop
statement.
Do(Box<StmtBlock>, Expr, OptionFlags, Position)
do
{
stmt }
while
|until
expr
Option Flags
- [
AST_FLAG_NONE
][AST_FLAGS::AST_FLAG_NONE] =while
- [
AST_FLAG_NEGATED
][AST_FLAGS::AST_FLAG_NEGATED] =until
Tuple Fields of Do
for
(
id ,
counter )
in
expr {
stmt }
Var(Expr, Box<Ident>, OptionFlags, Position)
[export
] let
|const
id =
expr
Option Flags
- [
AST_FLAG_EXPORTED
][AST_FLAGS::AST_FLAG_EXPORTED] =export
- [
AST_FLAG_CONSTANT
][AST_FLAGS::AST_FLAG_CONSTANT] =const
Tuple Fields of Var
expr op=
expr
FnCall(Box<FnCallExpr>, Position)
func (
expr ,
… )
Note - this is a duplicate of Expr::FnCall
to cover the very common pattern of a single
function call forming one statement.
Tuple Fields of FnCall
0: Box<FnCallExpr>
1: Position
{
stmt;
… }
try
{
stmt; … }
catch
(
var )
{
stmt; … }
Expr(Expr)
Tuple Fields of Expr
0: Expr
Continue(Position)
continue
Tuple Fields of Continue
0: Position
Break(Position)
break
Tuple Fields of Break
0: Position
Return(ReturnType, Option<Expr>, Position)
return
/throw
Tuple Fields of Return
import
expr as
var
Not available under no_module
.
export
var as
var ,
…
Not available under no_module
.
Convert a variable to shared.
Not available under no_closure
.
Implementations
Override the position of this statement.
Does this statement return a value?
Is this statement self-terminated (i.e. no need for a semicolon terminator)?
Is this statement pure within the containing block?
An internally pure statement only has side effects that disappear outside the block.
Only variable declarations (i.e. let
and const
) and import
/export
statements
are internally pure.
Does this statement break the current control flow through the containing block?
Currently this is only true for return
, throw
, break
and continue
.
All statements following this statement will essentially be dead code.
Trait Implementations
Auto Trait Implementations
impl !RefUnwindSafe for Stmt
impl !UnwindSafe for Stmt
Blanket Implementations
Mutably borrows from an owned value. Read more