Variables and Constants

Mux supports both explicit type declarations and type inference with the auto keyword.

Variable Declarations

Explicit Typing

variables.mux

Type Inference with `auto`

type_inference.mux

Important Rules

variable_rules.mux

auto needs an initializer, because there is nothing else to infer the type from. An explicit type does not. Semicolons are not used.

Declaring Without a Value

A declaration with an explicit type may omit the initializer, and be assigned later:

uninitialized_declaration.mux

use keeps a function flat when it makes several fallible calls. Reserve an uninitialized declaration for cases where different branches assign a value that has no useful default.

It matters most for types with no natural zero value. A string could be declared as "" and overwritten, but a class type has nothing to stand in - there is no empty TcpListener - so without this the value could not leave the arm that produced it.

Reading such a variable before it is assigned is a compile error, not a default value:

read_before_assignment.mux

The check is flow-sensitive: it follows every path to the read. A variable assigned in an if with no else is not assigned on all paths, and neither is one assigned in only some arms of a match. Every branch must either assign it or leave (return, or otherwise not reach the read).

Constants

Constants are immutable values that cannot be reassigned or modified after initialization:

constants.mux

Const Enforcement

Cannot reassign: const_var = new_value -> ERROR
Cannot use compound assignment: const_var += 1 -> ERROR
Cannot increment/decrement: const_var++ or const_var-- -> ERROR
Applies to both identifiers and class fields
Use const when you want a value that won't change after initialization

When to Use `auto`

Explicit Types Recommended

explicit_types.mux

Using Underscore for Unused Values

The underscore _ is a placeholder for values you don't need:

underscore.mux

Best Practice: Use _ when a value is required by syntax but not needed in your code. Don't overuse it when descriptive names would improve readability.

Variable Scope

Variables are scoped to the block in which they are declared:

scope.mux

Unless you create a closure, then you can capture variables from the enclosing scope:

closure_scope.mux

Variable Declarations​

Explicit Typing​

Type Inference with auto​

Important Rules​

Declaring Without a Value​

Constants​

Const Enforcement​

When to Use auto​

Recommended​

Explicit Types Recommended​

Using Underscore for Unused Values​

Variable Scope​

See Also​