Wie vermeidet man temporäre Zuordnungen bei der Verwendung eines komplexen Schlüssels für HashMap?

Question

Ich verwende einen komplexen Schlüssel für HashMap derart, dass der Schlüssel aus zwei Teilen bestehen und ein Teil ist ein String, und ich kann nicht herausfinden, wie Lookups über die HashMap::get Methode zu tun, ohne eine neues String für jeden lookup zuzuordnet.

Hier einige Code:

#[derive(Debug, Eq, Hash, PartialEq)] 
struct Complex { 
    n: i32, 
    s: String, 
} 

impl Complex { 
    fn new<S: Into<String>>(n: i32, s: S) -> Self { 
     Complex { 
      n: n, 
      s: s.into(), 
     } 
    } 
} 

fn main() { 
    let mut m = std::collections::HashMap::<Complex, i32>::new(); 
    m.insert(Complex::new(42, "foo"), 123); 

    // OK, but allocates temporary String 
    assert_eq!(123, *m.get(&Complex::new(42, "foo")).unwrap()); 
} 

Das Problem mit der letzten Behauptung ist. Es besteht, aber es erfordert eine temporäre Heap-Zuordnung, da ich kein Complex konstruieren kann, ohne ein String zu erstellen.

Um vorübergehende Zuweisungen wie diese zu beseitigen, bietet Rust die Borrow Eigenschaft, die die HashMap::get Methode verwendet. Ich verstehe, wie Borrow Arbeit für einfache Tasten, zum Beispiel zu machen, der Rust Standard Library des PathBuf implementiert Borrow<Path> durch die Verwendung von std::mem::transmute unter der Herstellung hauben aber ich kann nicht herausfinden, wie man es für meine Complex Art funktioniert:

#[derive(Debug)] 
struct Borrowable { 
    // ??? -- What goes here? Perhaps something like: 
    n: i32, 
    s1: &str, // ??? -- But what would the lifetime be? Or maybe: 
    s2: str, // ??? -- But how would I extend this to a complex type 
       //  containing two or more strings? 
} 

impl Borrowable { 
    fn new(n: i32, s: &str) -> &Self { 
     // ??? -- What goes here? It must not allocate. 
     unimplemented!(); 
    } 
} 

impl std::borrow::Borrow<Borrowable> for Complex { 
    fn borrow(&self) -> &Borrowable { 
     // ??? -- What goes here? How can I transmute a Complex into a 
     //  &Borrowable? 
     unimplemented!(); 
    } 
} 

Dies scheint wie ein häufiger Anwendungsfall, und ich vermute, ich vermisse etwas Wichtiges über Borrow, aber ich bin bei einem Totalverlust.

Answer 1

Es klingt wie du willst.

Cow akzeptiert eine &str oder String.

use std::borrow::Cow; 

#[derive(Debug, Eq, Hash, PartialEq)] 
struct Complex<'a> { 
    n: i32, 
    s: Cow<'a, str>, 
} 

impl<'a> Complex<'a> { 
    fn new<S: Into<Cow<'a, str>>>(n: i32, s: S) -> Self { 
     Complex { 
      n: n, 
      s: s.into(), 
     } 
    } 
} 

fn main() { 
    let mut m = std::collections::HashMap::<Complex, i32>::new(); 
    m.insert(Complex::new(42, "foo"), 123); 

    assert_eq!(123, *m.get(&Complex::new(42, "foo")).unwrap()); 
} 

Ein Kommentar über Lebensdauer Parameter:

Wenn Sie die Lebensdauer Parameter nicht und Sie müssen nur mit &'static str oder String arbeiten, dann können Sie Cow<'static, str> und entfernen Sie die anderen Lebensdauer Parameter aus der impl verwenden Block- und Strukturdefinition.