The Fortress Language Specification - CiteSeerX

declares id to be a mutable variable of type Type whose initial value is computed to be the value of the expression
expr . As before, the static type of expr must be a subtype of Type. The modifier var is optional when ‘ := ’ is used
instead of ‘ = ’ as follows:
[var] id : Type := expr
The first three forms are referred to as variable definitions. The fourth form:
[var] id : Type
declares a variable without giving it an initial value (where mutability is determined by the presence of the var
modifier). It is a static error if a variable is referred to before it has been given a value; an immutable variable is
initialized by another variable declaration and a mutable variable is initialized by assignment. It is also a static error
if an immutable variable is initialized more than once. Whenever a variable bound in this manner is assigned a value,
the type of that value must be a subtype of its declared type. This form allows declaration of the types of variables
to be separated from definitions, and it allows programmers to delay assigning to a variable before a sensible value is
known.
In short, immutable variables are declared and initialized by ‘ = ’ and mutable variables are declared and initialized by
‘ := ’ except when they are declared as the third form above with the modifier var .
All forms can be used with tuple notation to declare multiple variables together. Variables to declare are enclosed in
parentheses and separated by commas, as are the types declared for them:
(id[,id] + ) : (Type[, Type] + )
Alternatively, the types can be included alongside the respective variables, optionally eliding types that can be inferred
from context (see Chapter 20 for a discussion of type inference in Fortress):
(id[:Type][,id[: Type]] + )
Alternatively, a single type followed by ‘ . . . ’ can be declared for all of the variables:
(id[,id] + ):Type...
This notation is especially helpful when a function application returns a tuple of values.
Here are some simple examples of variable declarations:
π = 3.141592653589793238462643383279502884197169399375108209749445923078
declares the variable π to be an approximate representation of the mathematical object π . It is also legal to write:
π : R64 = 3.141592653589793238462643383279502884197169399375108209749445923078
This definition enforces that π has static type R64 .
In the following example, the declaration of the type of a variable and its definition are separated:
π : Float
π = 3.141592653589793238462643383279502884197169399375108209749445923078
The following example declares multiple variables using tuple notation:
var (x, y) : Z64 . . . = (5, 6)
The following three declarations are equivalent:
(x, y, z) : (Z64, Z64, Z64) = (0, 1, 2)
(x: Z64, y: Z64, z: Z64) = (0, 1, 2)
(x, y, z) : Z64 . . . = (0, 1, 2)
Special syntax is provided for declaring variables to be parts of a matrix, as described in Section 6.5.
57