2.5 Anonymous Structure
Anonymous structures can be used to group data without explicitly creating a type. The following example creates a structure with two fields x
and name
, and initializes their values to 12
and "foo"
respectively:
class Main {
static public function main() {
var myStructure = { x: 12, name: "foo"};
}
}
The general syntactic rules follow:
- A structure is enclosed in curly braces
{}
and - Has a comma-separated list of key-value-pairs.
- A colon separates the key, which must be a valid identifier, from the value.
- The value can be any Haxe expression.
Rule 4 implies that structures can be nested and complex, e.g.:
var user = {
name : "Nicolas",
age : 32,
pos : [
{ x : 0, y : 0 },
{ x : 1, y : -1 }
],
};
Fields of structures, like classes, are accessed using a dot (.
) like so:
// get value of name, which is "Nicolas"
user.name;
// set value of age to 33
user.age = 33;
It is worth noting that using anonymous structures does not subvert the typing system. The compiler ensures that only available fields are accessed, which means the following program does not compile:
class Test {
static public function main() {
var point = { x: 0.0, y: 12.0 };
// { y : Float, x : Float } has no field z
point.z;
}
}
The error message indicates that the compiler knows the type of point
: It is a structure with fields x
and y
of type Float
. Since it has no field z
, the access fails.
The type of point
is known through type inference, which thankfully saves us from using explicit types for local variables. However, if point
was a field, explicit typing would be necessary:
class Path {
var start : { x : Int, y : Int };
var target : { x : Int, y : Int };
var current : { x : Int, y : Int };
}
To avoid this kind of redundant type declaration, especially for more complex structures, it is advised to use a typedef:
typedef Point = { x : Int, y : Int }
class Path {
var start : Point;
var target : Point;
var current : Point;
}