Records

A record type is declared with fields in an intented block, each on their own line.

Defining a record implicitly defines a new function.
In the above example, its signature would be: new point(x float, y float)
Like any new function, it can be called with either 1, 2 or x: 1, y: 2.
The record also implicitly defines functions for getting each field.
In the above example, these would have signatures of x float(a point) and y float(a point).

Any record fields marked with mut are mutable. As with mutable locals, the mut goes before the type.

a.x := 3 is a syntax equivalent to calling set-x a, 3.

Mutable record fields implicitly define setter functions.
In this case, they are set-x void(a point, value float) and set-y void(a point, value float).

Since new functions are just ordinary functions, you can define additional new overloads.

Defining a record also implicitly creates a function with the same name as the record and the same signature as new.

point 1, 2 looks better than (1, 2)::point.
But if the type annotation is not necessary, prefer to write just 1, 2.

Declaring a record type point also implicitly declares:

• == bool(a point, b point)
• <=> comparison(a point, b point)
• hash void(a point, state hash-state)
• to json(a point)
• to point(a json)

These functions are only defined for immutable records with no private fields.

It is possible to define these functions explicitly yourself.
However, ==, <=>, and hash are unsafe to define yourself, so the body must be wrapped in trusted. (See Unsafe code.)
The reason they are unsafe is that badly written comparison or hash functions can break maps.
json conversion functions are safe to define yourself, but make sure a round trip (a.to::json.to::point) is the identity function.

If they were defined explicitly, they would look like this: