Type Aliases¶
In addition to declaring variables using var and
constants using const and param, Chapel
supports the declaration of type aliases using the type keyword.
These type aliases are used to create new names for existing types—in
particular, they do not create new [sub]types.
As an example of a simple type alias, consider the following statement:
type age = uint(8);
This declaration says to create a type alias named age which is
equivalent to the uint(8) type. Imagine that we’ll use this type
to store peoples’ ages, since they tend not to live more than 256
years. We can then use this alias like any other type. For example,
the following statements use it to declare some variables and to
declare the formal type of a procedure argument:
var mgAge: age = 10,
votingAge: age = 18;
proc birthday(ref a: age) {
a += 1;
}
birthday(mgAge);
Type aliases like age are useful for:
- creating self-documenting code: Using a type alias like age
provides more information about a variable than directly using the
uint(8)type would. - minimizing the number of code changes required to represent a
certain class of values: If we decided that we wanted to represent
other plants and animals in addition to people, we’d probably want
to redefine age to be a larger integer size in order to store the
ages of long-lived organisms like giant redwoods. It’s easier to do
this by changing a single type alias’s definition than by finding
all references to
uint(8)and determining whether or not they represent ages. - providing a shorthand for a longer type name: Typing age saves
keystrokes as compared to typing
uint(8).
Like the other declaration forms we’ve seen so far, the type
keyword can be used to declare multiple aliases by comma-separating
them. For example, the following statement creates float and
double as aliases to Chapel’s real(32) and real(64) types:
type float = real(32),
double = real(64);
Type aliases can be used not just for simple scalar types like
integers and floating point values, but for any Chapel type
expression. Though we haven’t introduced more complex types yet, the
following statements create aliases corresponding to a 3-tuple and
100-element array of real:
type vec = 3*real,
bigvec = [1..100] real;