Nicht übereinstimm Typen für zurückgegebene Struktur (erwartete <K, V>, gefunden <&K, &V>)

Question

den folgenden Code Given (die noch nicht viel tun):

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)) 
      }), 
     } 
    } 
} 

Der Compiler gibt die folgenden Fehler:

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>` 

Ich bin ziemlich neu in Rust, also bin ich mir nicht sicher, was das verursacht. Um absolut klar zu sein, die Frage, die ich habe, ist nicht über was die Fehlermeldung bedeutet. Natürlich bedeutet das, dass ich nicht den richtigen Typ zurückgebe. Die Frage ist warum interpretiert der Compiler diesen Code Split {...} als Code, der Split<'_, &K, &V> zurückgibt, wenn ich erwarte, dass es Split<'_, K, V> ist. Jeder Einblick wird geschätzt.

Answer 1

Die Referenzen stammen von wo aus man auf das Kind durchlaufen ein neues BTreeMap zu bauen:

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

dh die Iterator zurückkehrt:

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

Wenn man sich die iterator returned by BTreeMap::iter(), die Item Typ aussehen Paare von Referenzen auf den Inhalt. Dies ist sinnvoll, weil Sie beim Iterieren keine Elemente aus der Map verschieben oder sich auf Copy verlassen möchten.

Dies ist etwas anders als z.B. Vec::iter(), wobei es sich um ein Referenzpaar handelt und nicht um einen Verweis auf ein Paar. Dies ist sinnvoll, da ein Verweis auf ein Paar bedeuten würde, dass der Container diese Paare intern enthalten müsste (Einschränkung der internen Datenstruktur).

Die einfachste Sache ist, den Schlüssel und Wert zu klonen:

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