Expressions

Expressions in Mist are the fundamental units that evaluate to a value. The syntax follows a clean prefix → primary → postfix chain, providing a predictable structure that maps closely to Rust's mental model.

Primary Expressions

Primary expressions are the starting point of any logic chain. These include literal values, paths to static members, or grouped expressions in tuples.

// Literals and paths
var x = 42;
var y = Math::PI;

// Tuples
var coordinates = (10, 20, 30);

Postfix Operations

Postfix expressions allow you to build on a primary value. This includes calling functions, accessing fields, indexing arrays, or initializing structs.

// Field access and method/function calls
var len = list.length();

// Struct initialization
var task = Task {
    name: "Drafting",
    priority: 1,
};

// Indexing and Macro calls
var first = items[0];
println!("Value: {}", first); // Macro call via '!'

Prefix Operations

Prefixes modify the primary expression that follows them. Mist uses these for logical negation, dereferencing, and creating references.

var mut value = 10;

var ref = &value;         // Reference
var mref = &mut value;    // Mutable reference
var val = *ref;           // Dereference
var is_false = !true;     // Logical NOT

Binary Operations

Binary operations are applied as postfixes to an expression, following a bin_op ~ expr pattern. This supports all standard arithmetic, comparison, and logical operators.

var sum = 10 + 20;
var is_equal = (x == y);
var complex = (a + b) * (c / d);

Operator Table

Mist supports the following binary operators for comparisons and arithmetic:

Key Characteristics

• Predictable Chaining: The prefix* ~ primary ~ postfix* grammar ensures that complex expressions are parsed consistently, whether you are dereferencing a function call or indexing a struct field.
• Rust-Style References: While the pointer syntax type* is used in declarations, expressions use & and &mut to create references, maintaining compatibility with Rust's borrow checker.
• Macro Integration: Macros are treated as a postfix operation (!), allowing them to be called on identifiers just like standard functions.
• Unified Tuples: Tuples are primary expressions, allowing them to be passed, returned, or destructured seamlessly within the expression tree.