返回的结构类型不匹配（预期 <K, V> ，找到&lt;＆K，＆V&gt;）

Question

Given the following code (which doesn't do much yet):

use std::collections::BTreeMap;
use std::iter::FromIterator;

trait Node<K, V> {
    fn split(&self) -> Split<K, V>;
}

#[derive(Debug, Copy, Clone)]
pub struct Config {
    data_b: usize,
}

struct Split<'a, K, V> {
    left: Box<Node<K, V> + 'a>,
    right: Box<Node<K, V> + 'a>,
}

#[derive(Debug)]
pub struct DataNode<K, V> {
    cfg: Config,
    children: BTreeMap<K, V>,
}

impl<K: Clone + Ord, V: Clone> Node<K, V> for DataNode<K, V> {
    fn split(&self) -> Split<K, V> {
        let data_b = self.cfg.data_b;

        Split {
            left: Box::new(DataNode {
                cfg: self.cfg.clone(),
                children: BTreeMap::from_iter(self.children.iter().take(data_b))
            }),
            right: Box::new(DataNode {
                cfg: self.cfg.clone(),
                children: BTreeMap::from_iter(self.children.iter().rev().take(data_b))
            }),
        }
    }
}

The compiler gives the following error:

error[E0308]: mismatched types
  --> lib.rs:68:9
   |
68 |         Split {
   |         ^ expected type parameter, found &K
   |
   = note: expected type `Split<'_, K, V>`
   = note:    found type `Split<'_, &K, &V>`

I'm pretty new to Rust so I'm not sure what's causing this. To be absolutely clear, the question I'm having is not about what the error message means . Clearly, it means that I'm not returning the right type. The question is why does the compiler interpret this Split {...} code as code that returns Split<'_, &K, &V> when I expect it to be Split<'_, K, V> . Any insight is appreciated.

Answer 1

The references come from where you iterate on the child to build a new BTreeMap :

BTreeMap::from_iter(self.children.iter().take(data_b))

If you look at the iterator returned by BTreeMap::iter() , the Item type is:

type Item = (&'a K, &'a V)

ie the iterator returns pairs of references to the contents. This makes sense, because you don't want to move items out of the map when iterating, or rely on Copy .

This is slightly different from eg Vec::iter() , being a pair of references rather than a reference to a pair. This does make sense, as a reference to a pair would mean the container would have to actually contain those pairs internally (restricting the internal data structure).

The simplest thing is to clone the key and value:

BTreeMap::from_iter(self.children.iter()
                                 .map(|(&a, &b)| (a.clone(), b.clone()))
                                 .take(data_b))