Início / coding / Perguntas / 79016010
Accepted
BallpointBen
Asked: 2024-09-24 03:21:22 +0800 CST

Indexando um `HashMap<&String, V>` com `&str`

  • 772

Qual é a maneira correta de indexar em um HashMap<&String, V>com um &str? Rust relata que &Stringnão é Borrow<str>, o que é necessário para indexação. (Isso parece um pouco bobo para mim; se T: Borrow<U>então certamente &T: Borrow<U>também deveria ser válido?)

use std::collections::HashMap;

fn main() {
    let strings = vec!["x".to_owned(), "y".to_owned(), "z".to_owned()];
    let m = [0, 1, 2]
        .into_iter()
        .map(|i| (&strings[i], i))
        .collect::<HashMap<&String, usize>>();
    let zero = m["x"];
}

error[E0277]: the trait bound `&String: Borrow<str>` is not satisfied
 --> src/main.rs:9:18
  |
9 |     let zero = m["x"];
  |                  ^^^ the trait `Borrow<str>` is not implemented for `&String`, which is required by `HashMap<&String, usize>: Index<&_>`
  |
  = help: the trait `Borrow<str>` is implemented for `String`
  = help: for that trait implementation, expected `String`, found `&String`
  = note: required for `HashMap<&String, usize>` to implement `Index<&str>`

Obviamente, como eu construí esse HashMap em particular, eu poderia voltar e mudar seu tipo de chave para &strem vez disso. Mas supondo que eu receba um HashMap<&String, V>, qual é a maneira correta de indexá-lo? Construir um whole Stringapenas para pegar uma referência a ele parece desperdício.

rust

2 respostas

  1. Best Answer

    Existe uma maneira de contornar isso se você estiver disposto a mergulhar em águas perigosas.

    Esta solução aproveita o fato de que se você tiver uma struct Smarcada #[repr(transparent)]e contendo um único campo do tipo T, você pode transmutar com segurança de &'a Tpara &'b Sonde 'a: 'b. (É por isso que você pode pegar emprestado a &Pathde a PathBufmesmo que nenhum Pathnunca exista de fato , por exemplo.)

    Então, vamos construir um novo tipo que podemos pegar emprestado de String, e com um nome positivamente bikesheddable.

    #[derive(Hash, PartialEq, Eq)]
#[repr(transparent)]
struct StrRef(str);

    Essa definição nos permite transmutar com segurança de &strpara &StrRef, então vamos encapsular esse pedaço de código inseguro em uma Fromimplementação:

    impl<'a> From<&'a str> for &'a StrRef {
    fn from(value: &'a str) -> &'a StrRef {
        // SAFETY: StrRef is repr(transparent) and contains only a str.
        unsafe { &*(value as *const str as *const StrRef) }
    }
}

    Agora podemos implementar Borrow<StrRef>em qualquer tipo do qual podemos obter um &str.

    // Not actually needed, just for example.
impl Borrow<StrRef> for String {
    fn borrow(&self) -> &StrRef {
        self.as_str().into()
    }
}

// This is the impl you need in this case.
impl Borrow<StrRef> for &String {
    fn borrow(&self) -> &StrRef {
        self.as_str().into()
    }
}

    Por fim, isso nos permite escrever a seguinte função, que realiza seu objetivo de buscar no mapa usando um &strsem convertê-lo em um owned String:

    fn get_from_map<'a, T>(map: &'a HashMap<&String, T>, key: &str) -> Option<&'a T> {
    map.get(<&StrRef>::from(key))
}

    ( Parque infantil )

    Obviamente, se você puder alterar o tipo de chave do mapa, &strentão você deve preferir isso, mas se você não tem controle sobre a origem do mapa, então esta é uma solução viável (em um escopo -- esperançosamente -- muito limitado dentro do seu programa).

    • 6 
  2. impl<U, T: Borrow<U>> Borrow<U> for &T {

    conflitos com o existente

    impl<T> Borrow<T> for T {

    então não pode ser adicionado.

    Parque infantil

    Quando você está no controle, você não deve usar &Stringcomo chaves para começar. A maneira preferida seria usar &strque pode ser trivialmente criado a partir de a &Stringe você não tem o problema e é mais geral.

    Quando você não está no controle, criar um Stringíndice justo é sua única opção segura.

    • 5

relate perguntas