Control Flow

Control flow in Mist provides a bridge between C-style procedural logic and Rust's expression-oriented design. While many structures can return values, they follow a strict syntax for blocks and statements.

Conditionals

The if statement evaluates a boolean expression. It supports multiple else if branches and an optional else block.

if (score > 50) {
    println!("Pass");
} else if (score == 50) {
    println!("Borderline");
} else {
    println!("Fail");
}

Match

The match statement provides exhaustive pattern matching. Currently, every match arm requires a block {} following the => operator.

match (task_state) {
    TaskState::Pending => {
        println!("Queued");
    }
    TaskState::Failed { reason, code } => {
        println!("Error {}: {}", code, reason);
    }
    _ => {
        println!("Other state");
    }
}

Loops

Mist supports both functional iteration and traditional low-level loop control.

C-Style For Loop

For manual iteration control, Mist supports the standard three-part for loop: initialization, condition, and post-iteration statement.

for (var mut i = 0; i < 10; i = i + 1;) {
    println!("Index: {}", i);
}

For-In Loop

The for-in loop iterates over collections or iterators using Mist's pattern matching system.

for (var item in collection) {
    process(item);
}

// Destructuring within the loop
for ((i32 x, i32 y) in coordinates) {
    draw_point(x, y);
}

While Loop

The while loop continues execution as long as the parenthesized expression evaluates to true.

while (active) {
    wait_for_event();
}

Jump Statements

Execution flow can be interrupted or redirected using standard jump keywords.

• return: Exits the current function, optionally passing back a value.
• break: Terminates the innermost looping construct.
• continue: Skips the remainder of the current loop iteration and proceeds to the next.

Key Characteristics

• Pattern Integration: Loops and match arms utilize Mist's pattern system, allowing for seamless data destructuring during iteration.
• Explicit Scoping: Match items currently require explicit blocks, ensuring clear boundaries for variable shadowing and local logic.
• Familiar Iteration: The inclusion of C-style for loops provides fine-grained control for performance-critical logic where simple iteration is insufficient.
• Rust-Native Safety: Despite the procedural syntax, these structures compile to safe Rust, maintaining exhaustive checking and memory safety.