Question about Iterator and for loops

[hmuendel]

I just started learning rust and in my first project, I used your multi-map which worked like a charm.
However with std::collections::HashMap I can do a for loop over the map itself.

Trying the same with MultiMap:

use multi_map::MultiMap;

fn main() {
    let m = MultiMap::new();
    m.insert("k1", "k12", "v1");
    m.insert("k2", "k22", "v2");
    for (k, t) in m {
        println!("k: {} tuple: {:?}", k, t);
    }
}

error[E0277]: `multi_map::MultiMap<&str, &str, &str>` is not an iterator
 --> src/main.rs:7:19
  |
7 |     for (k, t) in m {
  |                   ^ `multi_map::MultiMap<&str, &str, &str>` is not an iterator
  |
  = help: the trait `std::iter::Iterator` is not implemented for `multi_map::MultiMap<&str, &str, &str>`
  = note: required by `std::iter::IntoIterator::into_iter`

I thought, easy: I will just implement the Iterator trait for MultiMap and contribute.

After forking, I saw that there is an .iter() method which returns an Iterator and which works fine iterating over. I still would like MultiMap to behave exactly like a HashMap as far as possible. So I started to look how HashMap implements Iterator and then my confusion was complete.
It appears that HashMap only implements IntoIter.?!?

So my noble intend to contribute, became a humble question about what makes sense.
Would it make sense to implement the trait, so MultiMap could be directly used in a for loop? I am happy to contribute, but hesitant due to my noobness.

[thejpster]

Ah, HashMap doesn't implement Iterator. It has a function called fn iter() -> std::collections::hash_map::Iter where std::collections::hash_map::Iter is a HashMap specific type that does implement Iterator<Item=(&K, &V)>.

In general, MultiMap should do what HashMap does, except where are changes are required because it has two keys, not one.

[thejpster]

To add IntoIter is also implemented for &HashMap, which I think is why you can use a HashMap in a for loop without consuming it, by doing:

for (k, v) in &map { .. }

In your gist, you're consuming the hashmap by implicitly calling IntoIterator on it directly, which takes self.

[hmuendel]

True, &m also works for HashMap. So what would be a reasonable design?
Doing it the same way as HashMap or implementing Iterator straightforward?
Should the iteration still be of the form ( k1, (k2, value)) or rather (k1, k2, value)?
Or is the existing MultiMap::iter() method good enough?

[thejpster]

I think we should start by implementing IntoIter for MultiMap and &MultiMap and implementing IntoIterMut for &mut MultiMap, just like HashMap does. The implementation of IntoIter will just call the existing fn iter() method (or iter_mut()).

[hmuendel]

If I am on the right track, I could also implement other iteratorish traits

• IterMut
• Keys
• Values
• ValuesMut
• Drain

for IterMut, I see the problem, that if we return a mutable reference to the tuple (K2, V) and the caller changes K2, this will not be in sync with the (K2, K1) Map.