Respuesta.

Historia de la pregunta

Las colecciones HashSet y HashMap son estructuras estándar de std::collections que implementan una búsqueda rápida por hash. Están integradas en Rust desde las primeras versiones del lenguaje, pero los detalles internos de su uso a menudo causan dificultades incluso a desarrolladores experimentados debido al sistema de propiedad.

Problema

La confusión surge al insertar y extraer elementos (especialmente si los valores no son Copy), al modificar la colección (prestamos mutables), así como al usar referencias como claves. También hay problemas con la implementación correcta de Eq/Hash para tipos personalizados.

Solución

Al agregar un elemento, la colección toma (move) la clave/valor, a menos que se use una referencia o un tipo que se pueda copiar.
Se puede modificar el contenido de manera segura solo a través de una referencia mutable a HashMap/HashSet.

Ejemplo de código:

use std::collections::HashMap;
fn main() {
    let mut map = HashMap::new();
    map.insert("key", 42);
    if let Some(value) = map.get("key") {
        println!("Encontrado valor: {}", value);
    }
}

Características clave:

Las claves en HashMap/HashSet deben implementar Hash, Eq
La inserción de un elemento siempre mueve (move) la variable a la colección
Solo se pueden extraer valores de manera segura mientras la colección no se modifique (reglas de préstamo)

Preguntas capciosas.

¿Se puede obtener múltiples referencias mutables a un mismo elemento de HashMap?

No, el verificador de préstamos no lo permitirá para evitar violaciones de propiedad.

¿Se puede usar un literal de cadena "abc" directamente como clave en HashMap<String, V>?

No, se espera exactamente un String, mientras que "abc" es &'static str. Se necesita conversión: insert("abc".to_string(), val).

¿Se puede extraer un valor de HashMap, almacenándolo en una variable separada y seguir usando HashMap?

Sí, se puede obtener una referencia al valor a través de get, pero si se hace remove (o se extrae por move), HashMap se muta, y cualquier referencia anterior se vuelve no válida.

Errores comunes y anti-patrones

Usar una referencia a una clave temporal al buscar (vivir tanto como map)
Implementar Hash/Eq para estructuras complejas sin considerar todos los campos (peligro de colisiones o comparaciones inconsistente)
Modificar la estructura de HashMap durante la iteración sobre referencias a sus valores

Ejemplo de la vida real

Caso negativo

Intentar tomar prestados simultáneamente tanto la clave como el valor, y luego mutar la colección:

let mut map = HashMap::new();
map.insert("abc".to_string(), 10);
let val = map.get("abc");
map.insert("def".to_string(), 20); // error del verificador de préstamos

Ventajas:

Código obvio desde la perspectiva de un principiante

Desventajas:

Error de compilación — no se puede tomar prestado mutablemente y no mutablemente al mismo tiempo

Caso positivo

Extracción de un valor, trabajando solo con su copia o clon:

let mut map = HashMap::new();
map.insert("abc".to_string(), 10);
if let Some(val) = map.get("abc") {
   let val = *val; // copiamos
   map.insert("def".to_string(), 20); // todo funciona
}