I was using the Haxe3 Release Candidate for well over a month before I realised that the new Map data structures could be created with a nice syntax. The basic gist is this:
var map1 = [ 1=>"one", 2=>"two", 3=>"three" ];
Like Arrays, but you use the “=>” operator to define both the key and the value. And Haxe’s type inference is as strong as ever. Here’s what the compiler picks up:
var map1 = [ 1=>"one", 2=>"two", 3=>"three" ];
$type (map1); // Map<Int, String>
var map2 = [ "one"=>1, "two"=>2, "three"=>3 ];
$type (map2); // Map<String, Int>
var map3 = [
Date.now() => "Today",
Date.now().delta(24*60*60*1000) => "Tomorrow",
Date.now().delta(-24*60*60*1000) => "Yesterday"
];
$type (map3); // Map<Date, String>
var map4 = [
{ name: "Tony Stark" } => "Iron Man",
{ name: "Peter Parker" } => "Spider Man"
];
$type (map4); // Map<{ name : String }, String>
var map5 = [
[1,2] => ["one","two"],
[3,4] => ["three","four"],
];
$type (map5); // Map<Array<Int>, Array<String>>
So it’s pretty clever. If for some reason you need to type explicitly to StringMap, IntMap, or ObjectMap, you can:
var stringMap:StringMap<Int> = [
"One" => 1,
"Two" => 2
];
$type(stringMap); // haxe.ds.StringMap<Int>
var intMap:IntMap<String> = [
1 => "One",
2 => "Two"
];
$type(intMap); // haxe.ds.IntMap<String>
var objectMap:ObjectMap<{ name:String }, String> = [
{ name: "Tony Stark" } => "Iron Man",
{ name: "Peter Parker" } => "Spider Man"
];
$type(objectMap); // haxe.ds.ObjectMap<{ name : String }, String>
But if you try to do anything too funky with types, the compiler will complain. Haxe likes to keep things strictly typed:
var funkyMap = [
{ name: "Tony Stark" } => "Iron Man",
{ value: "Age" } => 25
]; // Error: { value : String } has no field name ...
// you are a bad person, and your items are not comprehensible
// to Haxe's typing system
Finally, Haxe won’t let you do define duplicate keys using this syntax:
var mapWithDuplicates = [
1 => "One",
2 => "Two",
1 => "uno"
]; // Error: Duplicate Key ... previously defined (somewhere)
If you’re using an object map, it’s only a duplicate if you’re dealing with the exact same object, not a similar one. For example, this is allowed:
var similarObjectKeys:ObjectMap<Array<Int>, String> = [
[0] => "First Array object",
[0] => "Second Array object"
]; // Works, you now have 2 items in your map.
But if you use the exact same object, Haxe will pick it up:
var key = [0];
var sameObjectKey = [
key => "First Array object",
key => "Second Array object"
]; // Error: Duplicate Key ...
So there you have it. A nice feature that I didn’t see mentioned anywhere else. Thanks Haxe team!
….
Update:
It’s worth mentioning that once you have created your map, you can use array access (“[” and “]”) to read or modify entries in your map.
var map = [ 1=>"one", 2=>"two", 3=>"three" ];
// Reading a value
map[1]; "one"
var i = 2;
map[i]; "two"
map[++i]; "three"
// Setting a value
map[4] = "four";
map[1] = "uno";
map[i] = "THREE";
map; // [ 1=>"uno", 2=>"two", 3=>"THREE", 4=>"four" ]
