Records

Records are a way to wrap multiple values in a single value. A record is a collection of values that can be addressed by name. They are the equivalent of struct types in C.

Defining Records

Records are defined by the record declaration. The following:

record Vector3: Free is
    x: Float64;
    y: Float64;
    z: Float64;
end;

Is equivalent to this in C:

struct Vector3 {
    double x;
    double y;
    double z;
};

Don’t worry about the Free bit, this has to do with Austral’s linear type system, and will be explained later in the tutorial.

Constructing Records

Records are constructed using a function call-like syntax:

Vector3(x => 0.0, y => 0.0, z => 0.0);

Note that you have to use named arguments in record constructor expressions.

Accessing Record Values

Record values can be accessed using dot notation.

For example, the following:

let vec: Vector3 := Vector3(x => 0.0, y => 1.0, z => 2.0);
printLn(vec.y);

Will print 1.000000.

Destructuring

Destructuring lets you “explode” a record and turn each field into a variable. For example, instead of:

let vec: Vector3 := Vector3(x => 0.0, y => 1.0, z => 2.0);
printLn(vec.x);
printLn(vec.y);
printLn(vec.z);

You can write:

let vec: Vector3 := Vector3(x => 0.0, y => 1.0, z => 2.0);
let { x: Float64, y: Float64, z: Float64 } := vec;
printLn(x);
printLn(y);
printLn(z);

If the name of a field would collide with the name of another variable, you can rename them:

let { x as x0: Float64, y as y0: Float64, z as z0: Float64 } := vec;
printLn(x0);
printLn(y0);
printLn(z0);