How do I concisely fill a 2D HashMap?

Question

Is there a simple way to fill a 2 dimensional HashMap? In C++ I could do something along the lines of:

std::unordered_map<int,std::unordered_map<int,int>> 2dmap;
//...
2dmap[0][0] = 0;
2dmap[0][1] = 1;
//...

In my Rust project I am trying to fill a similar map:

let mut map: HashMap<i32, HashMap<i32, i32>> = HashMap::new();
//...fill the hash map here.

The only way that I can think to do this would be to build each sub map then move them into the super map, something like this:

let mut sub1: HashMap<i32, i32> = HashMap::new();
sub1.insert(0, 0);
sub1.insert(1, 1);
let mut map: HashMap<i32, HashMap<i32, i32>>::new();
map.insert(0, sub1);

Is there a more concise way to do this?

The above code is a simplification of my actual use case which uses an enum as the index of the HashMap:

enum Example {
    Variant1,
    Variant2,
    //...
}

None of the variants hold a value. I am using this syntax for the lookup from my HashMap:

let value = map[Example::Variant1][Example::Variant2];

Answer 1

In Rust, tuples work really well. You probably should just use HashMap<(i32, i32), i32>. Then, you end up with something very close to the C++ code.

let mut map: HashMap<(i32, i32), i32> = HashMap::new();
sub1.insert((0, 0), 0);
sub1.insert((0, 1), 1);
// ...

Naturally, it would be nice if we had a macro like vec! for this, and an RFC is in the works. Using the macro from this answer, you can write:

let map = hashmap![(0,0) => 0, (0,1) => 1, ...];

Nothing changes if you are using an enum - just make sure you derive Eq, PartialEq, and Hash for it.

let mut sub1: HashMap<(Example, Example), i32> = HashMap::new();
sub1.insert((Example::Variant1, Example::Variant1), 0);
sub1.insert((Example::Variant1, Example::Variant2), 1);
// ...

Answer 2

Use the entry API:

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.entry(0).or_insert_with(HashMap::new).insert(0, 0);
    map.entry(0).or_insert_with(HashMap::new).insert(1, 1);

    println!("{:?}", map);
    println!("{}", map[&0][&1]);
}

Unlike C++, constructing the nested HashMap is not implicit - you have to be very clear that you wish to allow a new HashMap to be created.

---

Unlike the other answer, this preserves the original data structure and ability to get a subset of the overall map based on just the initial key:

println!("{:?}", map.get(&0));
println!("{:?}", map.get(&0).and_then(|m| m.get(&1)));

If you always provide both numeric indices, then a tuple is a much better solution as it more accurately models the problem — there's only one true key, it just happens to have two components. It also is likely to have better data locality as there's one big slab of memory, as opposed to the extra level of pointer-chasing a hash of hashes would entail.

Answer 3

The C++ code snippet owes its brevity to the convenient operator [] which automatically default-constructs the value if it is missing in the map. While Rust doesn't do this by default, it's easy enough to tell it to do so, as shown in Shepmaster's answer.

To avoid having to spell out entry(key).or_insert_with(ValueType::new), it is possible to add the method equivalent to C++'s operator [] to Rust's HashMap. After all, Rust has the necessary tools - it supports adding methods to existing types using traits, and it has a trait roughly equivalent to C++'s default constructor.

The C++ expressions:

map[0][0] = 0;
map[0][1] = 1;

would be written as the following Rust, using a method that returns a reference in place of operator []:

*map.ensure(0).ensure(0) = 0;
*map.ensure(0).ensure(1) = 1;

ensure would be declared in a trait which must be imported by code that wants to get the method:

use std::collections::HashMap;
use std::hash::Hash;

trait MapDefault<K, V: Default> {
    fn ensure(&mut self, key: K) -> &mut V;
}

...and defined like this:

impl<K: Eq + Hash, V: Default> MapDefault<K, V> for HashMap<K, V> {
    fn ensure(&mut self, key: K) -> &mut V {
        self.entry(key).or_insert_with(V::default)
    }
}

It would be nice to be able to define IndexMut for HashMap, which would shorten the expression to *map[0][0] = 0, which is almost exactly like the C++ original, but unfortunately Rust doesn't allow implementing operators for types from other modules.