Enum Statement

pub enum Statement {
    VarDeclaration {
        name: String,
        value: Expression,
        is_const: bool,
    },
    Assignment {
        target: AssignmentTarget,
        operator: AssignmentOperator,
        value: Expression,
    },
    Expression(Expression),
    If {
        condition: Expression,
        then_branch: Vec<Statement>,
        else_branch: Option<Vec<Statement>>,
    },
    While {
        condition: Expression,
        body: Vec<Statement>,
    },
    For {
        variable: String,
        iterable: Expression,
        body: Vec<Statement>,
    },
    Function {
        name: String,
        parameters: Vec<Parameter>,
        body: Vec<Statement>,
        return_type: Option<Type>,
    },
    Return(Option<Expression>),
    Break,
    Continue,
    Block(Vec<Statement>),
}

Top-level statements in OpenScript

Variants

VarDeclaration

Variable declaration: let x = 5 or const y = "hello"

Fields

name: String

The name of the variable

value: Expression

The initial value of the variable

is_const: bool

Whether the variable is constant

Assignment

Assignment: x = 10 or x += 5

Fields

target: AssignmentTarget

The target of the assignment

operator: AssignmentOperator

The assignment operator

value: Expression

The value to assign

Expression(Expression)

Expression statement: print("hello")

If

If statement with optional else

Fields

condition: Expression

The condition to evaluate

then_branch: Vec<Statement>

The block to execute if the condition is true

else_branch: Option<Vec<Statement>>

The optional block to execute if the condition is false

While

While loop

Fields

condition: Expression

The condition to evaluate

body: Vec<Statement>

The body of the loop

For

For loop: for item in collection

Fields

variable: String

The name of the loop variable

iterable: Expression

The expression to iterate over

body: Vec<Statement>

The body of the loop

Function

Function definition

Fields

name: String

The name of the function

parameters: Vec<Parameter>

The parameters of the function

body: Vec<Statement>

The body of the function

return_type: Option<Type>

The optional return type of the function

Return(Option<Expression>)

Return statement

Break

Break statement

Continue

Continue statement

Block(Vec<Statement>)

Block statement

Implementations

impl Statement

pub fn is_control_flow(&self) -> bool

Check if this statement can affect control flow

pub fn is_declaration(&self) -> bool

Check if this is a declaration statement

Trait Implementations

impl Clone for Statement

fn clone(&self) -> Statement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Statement

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Statement

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Statement

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Statement