委派给 HashMap 迭代器时如何消除“预期 &T，找到类型参数”错误？

Question

I'm trying to build a small graph library in Rust. A Graph trait will be implemented by all graphs, and HashGraph is a specific example. HashGraph itself will be a lightweight wrapper around HashMap .

In particular, I want the HashGraph method nodes to return an iterator that delegates next to an underlying iterator obtained from HashGraph#keys .

Here's my code:

use std::collections::HashMap;

pub trait Graph<'a, N: 'a> {
    type Nodes: Iterator<Item=&'a N>;

    fn nodes(&'a self) -> Self::Nodes;
}

struct HashGraph<N> {
    map: HashMap<N, ()>
}

impl<N> HashGraph<N> {
    pub fn new(map: HashMap<N, ()>) -> Self {
        HashGraph { map }
    }
}

impl<'a, N: 'a> Graph<'a, &'a N> for HashGraph<N> {
    type Nodes = NodeIterator<'a, &'a N>;

    fn nodes(&'a self) -> Self::Nodes {
        NodeIterator::new(self.map.keys())
    }
}

struct NodeIterator<'a, N> {
    nodes: std::collections::hash_map::Keys<'a, N, ()>
}

impl<'a, N> NodeIterator<'a, N> {
    pub fn new(nodes: std::collections::hash_map::Keys<'a, N, ()>) -> Self {
        NodeIterator { nodes: nodes }
    }
}

impl<'a, N> Iterator for NodeIterator<'a, N> {
    type Item = &'a N;

    fn next(&mut self) -> Option<Self::Item> {
        self.nodes.next()
    }
}

I'm trying to avoid Boxing iterators using the technique described in the answers here .

This code does not compile due to a single error:

   |
23 |         NodeIterator::new(self.map.keys())
   |                           ^^^^^^^^^^^^^^^ expected &N, found type parameter
   |
   = note: expected type `std::collections::hash_map::Keys<'_, &N, _>`
              found type `std::collections::hash_map::Keys<'_, N, _>`

It appears that the HashMap keys iterator isn't returning the expected form of the item, but I'm really unclear how to fix this error. My goal with NodeIterator is to just pass on whatever the HashMap iterator returns for next .

HashGraph should own its keys (the ones in its HashMap ). Once created, HashGraph will be read-only.

The use of HashMap<N, ()> is mainly to simplify the sample code. It will ultimately use HashMap<N, HashMap<N, E>> where E is an edge weight. Clients would take care of ensuring proper ownership in the HashMap they pass with, for example, reference counting.

How can I modify the sample to eliminate the error and successfully compile?

Answer 1

To get the code compiling, you only need to remove a couple of extra & s.

use std::collections::HashMap;

pub trait Graph<'a, N: 'a> {
    type Nodes: Iterator<Item = &'a N>;

    fn nodes(&'a self) -> Self::Nodes;
}

struct HashGraph<N> {
    map: HashMap<N, ()>,
}

impl<N> HashGraph<N> {
    pub fn new(map: HashMap<N, ()>) -> Self {
        HashGraph { map }
    }
}

impl<'a, N: 'a> Graph<'a, N> for HashGraph<N> {
    //                   ^^^ this one
    type Nodes = NodeIterator<'a, N>;
    //                           ^^^ and this one

    fn nodes(&'a self) -> Self::Nodes {
        NodeIterator::new(self.map.keys())
    }
}

struct NodeIterator<'a, N> {
    nodes: std::collections::hash_map::Keys<'a, N, ()>,
}

impl<'a, N> NodeIterator<'a, N> {
    pub fn new(nodes: std::collections::hash_map::Keys<'a, N, ()>) -> Self {
        NodeIterator { nodes }
    }
}

impl<'a, N> Iterator for NodeIterator<'a, N> {
    type Item = &'a N;

    fn next(&mut self) -> Option<Self::Item> {
        self.nodes.next()
    }
}

(playground)

The reasons for this come down to the signatures on the trait Graph and the struct NodeIterator . When fed Keys<'a, N, ()> , NodeIterator::new returns NodeIterator<'a, N> . However, for your implementation of Graph you want it to return something of type Nodes , which is the type NodeIterator<'a, &'a N> . Notice the extra &'a . Moreover, it needs to return an iterator whose items have type &'a N . Removing some of the &'a s makes everything consistent.

Another solution is to add an extra &'a .

impl<'a, N: 'a> Graph<'a, &'a N> for HashGraph<&'a N> {
    //                                         ^^^ right here
    type Nodes = NodeIterator<'a, &'a N>;

    fn nodes(&'a self) -> Self::Nodes {
        NodeIterator::new(self.map.keys())
    }
}

(playground)

That would mean that you're consistently using &'a N rather than N itself.

The key here is consistency, but you'll also want to think ahead to how you're going to use these types and traits. Do you want HashGraph to only have references to its keys or own them? If they're references, what actually owns them? If you use owned keys, are you going to need to move them around a lot?

One last thing. You're using HashMap<N, ()> but, depending on what exactly you're trying to do, HashSet<N> might be more idiomatic. The two are exactly the same under the hood, but HashSet has a different set of methods that may or may not be more useful for you.