¿Cómo buscar e insertar en un HashMap de manera eficiente?

Me gustaría hacer lo siguiente:

Busque Vecuna clave determinada y guárdela para su uso posterior.
Si no existe, cree un espacio vacío Vecpara la clave, pero manténgalo aún en la variable.

¿Cómo hacer esto de manera eficiente? Naturalmente pensé que podría usar match:

use std::collections::HashMap;

// This code doesn't compile.
let mut map = HashMap::new();
let key = "foo";
let values: &Vec<isize> = match map.get(key) {
    Some(v) => v,
    None => {
        let default: Vec<isize> = Vec::new();
        map.insert(key, default);
        &default
    }
};

Cuando lo probé me dio errores como:

error[E0502]: cannot borrow `map` as mutable because it is also borrowed as immutable
  --> src/main.rs:11:13
   |
7  |     let values: &Vec<isize> = match map.get(key) {
   |                                     --- immutable borrow occurs here
...
11 |             map.insert(key, default);
   |             ^^^ mutable borrow occurs here
...
15 | }
   | - immutable borrow ends here

Terminé haciendo algo como esto, pero no me gusta el hecho de que realiza la búsqueda dos veces ( map.contains_keyy map.get):

// This code does compile.
let mut map = HashMap::new();
let key = "foo";
if !map.contains_key(key) {
    let default: Vec<isize> = Vec::new();
    map.insert(key, default);
}
let values: &Vec<isize> = match map.get(key) {
    Some(v) => v,
    None => {
        panic!("impossiburu!");
    }
};

¿Existe una manera segura de hacer esto con solo uno match?

Feb 14 '15 11:02 Yusuke Shinyama

La entryAPI está diseñada para esto. En forma manual, podría verse así

let values = match map.entry(key) {
    Entry::Occupied(o) => o.into_mut(),
    Entry::Vacant(v) => v.insert(default),
};

Se puede utilizar el formulario más breve a través de Entry::or_insert_with:

let values = map.entry(key).or_insert_with(|| default);

Si defaultya está calculado, o si está bien o es barato calcularlo incluso cuando no está insertado, puede usar Entry::or_insert:

let values = map.entry(key).or_insert(default);

Si el HashMapvalor de 'se implementa Default, puede utilizarlo Entry::or_default, aunque es posible que deba proporcionar algunas sugerencias de tipo:

let values = map.entry(key).or_default();

Feb 14 '2015 04:02 huon

Utilicé la respuesta de Huon y la implementé como un rasgo:

use std::collections::HashMap;
use std::hash::Hash;

pub trait InsertOrGet<K: Eq + Hash, V: Default> {
    fn insert_or_get(&mut self, item: K) -> &mut V;
}

impl<K: Eq + Hash, V: Default> InsertOrGet<K, V> for HashMap<K, V> {
    fn insert_or_get(&mut self, item: K) -> &mut V {
        return match self.entry(item) {
            std::collections::hash_map::Entry::Occupied(o) => o.into_mut(),
            std::collections::hash_map::Entry::Vacant(v) => v.insert(V::default()),
        };
    }
}

Entonces puedo hacer:

use crate::utils::hashmap::InsertOrGet;

let new_or_existing_value: &mut ValueType = my_map.insert_or_get(my_key.clone());

Feb 27 '2021 10:02 Daniel