[go: up one dir, main page]

Enum rhai::Stmt[−][src]

pub enum Stmt {
    Noop(Position),
    If(Expr, Box<(Stmt, Option<Stmt>)>, Position),
    Switch(Expr, Box<(HashableHashMap<u64, Stmt, StraightHasherBuilder>, Option<Stmt>)>, Position),
    While(Expr, Box<Stmt>, Position),
    Do(Box<Stmt>, Expr, bool, Position),
    For(Expr, Box<(String, Stmt)>, Position),
    Let(Box<Ident>, Option<Expr>, bool, Position),
    Const(Box<Ident>, Option<Expr>, bool, Position),
    Assignment(Box<(Expr, Cow<'static, str>, Expr)>, Position),
    Block(Vec<Stmt>, Position),
    TryCatch(Box<(Stmt, Option<Ident>, Stmt)>, Position, Position),
    Expr(Expr),
    Continue(Position),
    Break(Position),
    Return((ReturnType, Position), Option<Expr>, Position),
    Import(Expr, Option<Box<Ident>>, Position),
    Export(Vec<(Ident, Option<Ident>)>, Position),
    Share(Ident),
}

(INTERNALS) A statement. Exported under the internals feature only.

Volatile Data Structure

This type is volatile and may change.

Variants

Noop(Position)

No-op.

if expr { stmt } else { stmt }

Switch(Expr, Box<(HashableHashMap<u64, Stmt, StraightHasherBuilder>, Option<Stmt>)>, Position)

switch expr { literal or _ => stmt , ... }

While(Expr, Box<Stmt>, Position)

while expr { stmt }

do { stmt } while|until expr

for id in expr { stmt }

[export] let id = expr

Const(Box<Ident>, Option<Expr>, bool, Position)

[export] const id = expr

Assignment(Box<(Expr, Cow<'static, str>, Expr)>, Position)

expr op= expr

Block(Vec<Stmt>, Position)

{ stmt; ... }

try { stmt; ... } catch ( var ) { stmt; ... }

Expr(Expr)

expression

Continue(Position)

continue

Break(Position)

break

return/throw

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

import expr as var

export var as var , ...

Share(Ident)

Convert a variable to shared.

Implementations

impl Stmt[src]

pub fn is_noop(&self) -> bool[src]

Is this statement Noop?

pub fn position(&self) -> Position[src]

Get the position of this statement.

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

Notable traits for &'_ mut R

impl<'_, R> Read for &'_ mut R where
    R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;
[src]

Override the position of this statement.

pub fn is_self_terminated(&self) -> bool[src]

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

pub fn is_pure(&self) -> bool[src]

Is this statement pure?

A pure statement has no side effects.

pub fn walk<'a>(
    &'a self,
    path: &mut Vec<ASTNode<'a>>,
    on_node: &mut impl FnMut(&[ASTNode<'_>])
)[src]

Recursively walk this statement.

Trait Implementations

impl Clone for Stmt[src]

impl Debug for Stmt[src]

impl Default for Stmt[src]

impl<'a> From<&'a Stmt> for ASTNode<'a>[src]

impl Hash for Stmt[src]

Auto Trait Implementations

impl !RefUnwindSafe for Stmt[src]

impl !Send for Stmt[src]

impl !Sync for Stmt[src]

impl Unpin for Stmt[src]

impl !UnwindSafe for Stmt[src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> CallHasher for T where
    T: Hash + ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.