Variables

In Mist, variables follow the language-wide type name convention. For local scope, the var keyword provides type inference, while explicit types can be used for clarity or strictness.

Basic Declaration

Variables are declared using the var keyword for automatic type inference. Like Rust, variables are immutable by default.

var message = "Hello Mist"; // Inferred as str*
var count = 42;             // Inferred as i32

Mutability

To allow a variable to be reassigned, use the mut modifier after the var keyword or the explicit type.

var mut score = 0;
score = 100;

f32 mut price = 19.99;
price = 14.99;

Explicit Typing

While var handles inference, you can explicitly define the type before the identifier. This is often used for clarity in complex logic or when the specific numeric width (e.g., u8 vs i32) matters.

u64 large_id = 1000234;
bool is_active = true;

Pattern Destructuring

Because variable declarations are patterns, you can destructure tuples or structures directly. This keeps data extraction clean and avoids manual indexing.

// Destructuring a tuple into local variables
(i32, i32) (x, y) = get_coordinates();

// Using 'var' within a pattern for inference
(String, i32) (name, age) = get_user_info();

Constants

Constants are immutable values that are evaluated at compile time. They require an explicit type and follow the const keyword.

const i32 MAX_RETRIES = 5;
const str* VERSION = "1.0.4";

Key Characteristics

• Predictable Order: Whether using var or an explicit type, the name of the variable always follows the "source" of its data.
• Safety First: Immutability by default prevents accidental state changes, mapping directly to Rust's memory safety model.
• Zero-Cost Inference: Type inference is handled entirely at compile time, ensuring there is no runtime performance penalty.
• Shadowing: Mist supports variable shadowing, allowing you to reuse variable names within the same scope to transform data without changing mutability.