≔ (colon equals)
The assignment operator.
Syntax

a[, b[, ...]] ≔ X

a, b, ...
are lvalues 
X
is any object


a1, a2, ..., an ≔ X1, X2, ..., Xn

a1, a2, ..., an
are lvalues 
X1, X2, ..., Xn
are any objects

Description
≔
is the assignment operator. It is most easily inserted by typing a colon (:) followed by an equals sign (=) and then any whitespace or punctuation.
In its simplest form, a ≔ X
, it assigns the value X
to the variable a
. If there isn’t already a variable named a
, it is created with value X
; otherwise, its current value is discarded and replaced with X
. a
must be a valid identifier.
The expression a ≔ X
returns X
, so it is possible to write a ≔ b ≔ X
, parsed as a ≔ (b ≔ X)
because the ≔
operator is evaluated righttoleft, to assign X
to both a
and b
. Consequently, the value of a ≔ b ≔ X
is also X
.
It is possible to assign the same value to multiple lvalues at once without having to use multiple assignment operators:
a, b, c ≔ X
will assign the value X
to all lvalues to the left of the operator – in this case, to a
, b
, and c
. Again, the expression a, b, c ≔ X
returns X
.
Finally, it is possible to assign several different values to different destination lvalues. For example (n = 3),
a, b, c ≔ X, Y, Z
will assign X
to a
, Y
to b
, and Z
to c
. If the number of values to the right is greater than one, then the number of lvalues on the left must be the same number. The value of the expression a, b, c ≔ X, Y, Z
is Z
; in general (any n
), it is the rightmost value.
The expression
a, b, c ≔ X, Y, Z
is similar to
a ≔ X; b ≔ Y; c ≔ Z.
Assuming no error occurs (and no flowcontrol value is returned), the side effects and returned value are the same.
If an error is generated, however, the side effects differ. While
a ≔ 10; b ≔ 100; c ≔ 1000/0
will set a
and b
before the error occurs,
a, b, c ≔ 10, 100, 1000/0
will not set any variable, because the assignment operator’s righthandside values are evaluated before any assignment takes place.
Another consequence of this is that it is possible to use the assignment operator to swap two values:
a, b ≔ b, a.
In general, an lvalue (lefthandside operand) need not be a variable name. It can also be a subscripted member of a variable, nested to any level.
For example,
X ≔ struct("a": 10, "b": struct("first": '(4, 1, '(2, 6)), "second": 20))
a: 10 b.first: (4, 1, (2, 6)) b.second: 20
X.b.first[3][1] ≔ 20
20
X
a: 10 b.first: (4, 1, (20, 6)) b.second: 20
Some functions also return lvalues, such as MainDiagonal
and row
:
A ≔ ❨❨5, 1, 2❩, ❨2, 5, 7❩, ❨0, 1, 2❩❩
⎛5 1 2⎞ ⎜2 5 7⎟ ⎝0 1 2⎠
MainDiagonal(A) ≔ ❨10, 100, 1000❩
⎛ 10 ⎞ e⎜100 ⎟ ⎝1000⎠
A
⎛ 10 1 2⎞ ⎜ 2 100 7⎟ ⎝ 0 1 1000⎠
row(A, 1) ≔ ❨−1, −2, −3❩
⎛−1⎞ e⎜−2⎟ ⎝−3⎠
A
⎛ −1 −2 −3⎞ ⎜ 2 100 7⎟ ⎝ 0 1 1000⎠
Note that planar containers (such as matrices and pixmaps) have twodimensional indices that can function like lvalues:
A[3, 1] ≔ π
3.14159265359 (=π)
A
⎛ −1 −2 −3⎞ ⎜ 2 100 7⎟ ⎝3.14159265359 1 1000⎠
If a variable is protected, it cannot be assigned a new value. It is also not possible to assign a new value to any subscript of the variable.
The ≔
operator is implemented by the assign
function.