Как избежать временных распределений при использовании сложного ключа для HashMap?

Question

Я использую сложный ключ для HashMap, так что ключ состоит из двух частей, а одна часть - String, и я не могу понять, как выполнять поиск с помощью метода HashMap::get, не выделяя новый String для каждого поиска.

Вот код:

#[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()); 
} 

Проблема заключается с окончательным утверждением. Она проходит, но это требует временного распределения кучи, потому что я не могу построить Complex без построения String.

Чтобы устранить временные распределения, подобные этому, Rust предоставляет свойство Borrow, которое использует метод HashMap::get. Я понимаю, как сделать Borrow работы для простых ключей, например, ржавчина стандартной библиотеки PathBuf орудий Borrow<Path> пути использования std::mem::transmute под капотом, но я не могу понять, как заставить его работать на мой Complex типа:

#[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!(); 
    } 
} 

Это похоже общее использование, и, я подозреваю, что я что-то важное о Borrow не хватаю, но я в полной потере.

Answer 1

Это звучит, как вы хотите это.

Cow примет &str или 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()); 
} 

Комментарий о пожизненных параметрах:

Если вам не нравится параметр времени жизни, и вы должны работать только с &'static str или String, то вы можете использовать Cow<'static, str> и удалить другие параметры продолжительности жизни от осущий определение блока и структуры.