Variable declarations

In Motoko, variables are declared using:

• let for immutable bindings: Once assigned, the value cannot be changed.

• var for mutable bindings: The value can be updated later.

Immutable variables

The let keyword is used to bind a name to the result of an expression, creating an immutable variable. In a let declaration, the expression on the right-hand side is evaluated once, and its resulting value is associated with the given name. This value cannot be changed after the initial assignment. The Motoko compiler enforces this immutability by generating a compile-time error if there is any attempt to modify the variable later in the code.

In concurrent code, immutable declarations should be preferred over mutable declarations, since they prevent concurrent modification.

let x = 10;
x := 20; // Error: Cannot assign to immutable variable

The left hand side of a let can be also be a more general pattern, naming the components of a value by matching its structure:

For example, the declaration:

let (fst, snd) = (1, 2); 

uses the pattern (fst, snd) to name the components of the pair (1,2). The value of fst is 1 and the value of snd is 2. Both fst and snd are immutable.

Mutable variables

A var declaration in Motoko defines a mutable variable whose value can be updated after it is initially assigned. Unlike let, which creates an immutable binding, var allows reassignment using the := operator. This means that the variable can hold different values over time, making it suitable for scenarios where state changes are required.

var y = 10;
y := 20; // Allowed, updates the value of y

Unlike, let declarations, var declarations do not support pattern matching. For example, the following is a syntax error:

var (a, b) = (1, 2); // Not supported