66 lines
2.2 KiB
Plaintext
66 lines
2.2 KiB
Plaintext
---
|
|
title: Variables
|
|
description: Local state management with type inference and explicit mutability.
|
|
icon: Variable
|
|
---
|
|
|
|
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.
|
|
|
|
```mist
|
|
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.
|
|
|
|
```mist
|
|
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.
|
|
|
|
```mist
|
|
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.
|
|
|
|
```mist
|
|
// 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.
|
|
|
|
```mist
|
|
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.
|