Hash y Default: claves de mapa y valores por defecto

Para meter un tipo como clave de un HashMap no basta con poder compararlo: hace falta poder resumirlo en una huella numérica, y de eso se encarga Hash. Para pedir “una instancia con valores sensatos” sin rellenar todos los campos a mano, existe Default. Son dos traits modestos comparados con los del resto del nivel, pero sostienen las colecciones asociativas y aparecen por todo el ecosistema. Y Hash esconde un contrato con Eq que, si lo rompes, corrompe tus mapas en silencio.

Hash: la huella para las claves

Un HashMap guarda cada clave en un bucket elegido a partir de una huella numérica de esa clave. Para poder calcular esa huella, la clave debe implementar Hash. La combinación exigida a toda clave es Eq + Hash.

use std::collections::HashMap;

#[derive(PartialEq, Eq, Hash)]
struct ClaveGeo {
    pais: String,
    ciudad: String,
}

fn main() {
    let mut poblacion = HashMap::new();
    poblacion.insert(
        ClaveGeo { pais: String::from("ES"), ciudad: String::from("Madrid") },
        3_300_000,
    );
    let clave = ClaveGeo { pais: String::from("ES"), ciudad: String::from("Madrid") };
    assert_eq!(poblacion.get(&clave), Some(&3_300_000));
}

Hash se deriva y, como todos los derivables estructurales, funciona campo a campo: la huella del struct combina las huellas de sus campos. Por eso ClaveGeo puede derivar Hash: String ya lo implementa.

El contrato Eq–Hash

Aquí vive la ley más importante del trait, y es fácil de enunciar: si dos valores son iguales, deben tener la misma huella. Formalmente, a == b obliga a que hash(a) == hash(b).

La razón es el funcionamiento del mapa. Para buscar una clave, el HashMap calcula su huella, va al bucket correspondiente y allí compara con ==. Si dos claves iguales produjeran huellas distintas, irían a buckets distintos, y buscar una clave que insertaste devolvería None: el valor está ahí, pero el mapa lo busca en el sitio equivocado. No es undefined behavior, pero sí una corrupción lógica silenciosa, de las que cuestan horas de depuración.

Por eso la regla práctica es tajante: deriva Eq y Hash juntos, o impleméntalos juntos con sumo cuidado, pero nunca uno a mano y el otro derivado. El derive los mantiene consistentes por construcción, porque ambos recorren los mismos campos en el mismo orden.

Hash frente a Hasher: quién aporta los bytes y quién calcula

Un matiz de diseño precioso: Hash no calcula ninguna huella. Lo que hace su método hash es alimentar con bytes a un Hasher genérico que se le pasa. El Hasher es quien mezcla esos bytes en un número final.

use std::hash::{Hash, Hasher};

struct Punto { x: i32, y: i32 }

impl Hash for Punto {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.x.hash(state);   // aporto los bytes de x al hasher
        self.y.hash(state);   // ...y los de y; NO calculo el numero final
    }
}

Esta separación tiene consecuencias reales. Hash responde a “¿qué bytes representan este valor?”; Hasher responde a “¿cómo mezclo bytes en una huella?”. Como están desacopladas, std puede usar por defecto el algoritmo SipHash —resistente a ataques de colisión deliberados que podrían degradar un HashMap a listas—, y tú puedes cambiar a un Hasher más rápido como el de FxHashMap o ahash sin tocar ni una línea de los impl Hash de tus tipos. La representación de tus datos y el algoritmo de mezcla evolucionan por separado.

Default: el valor por defecto

Default responde a “dame una instancia con valores razonables”. Se deriva, y da a cada campo su propio valor por defecto: 0 para enteros, false para bool, cadena vacía para String, vector vacío para Vec, None para Option.

#[derive(Default, Debug)]
struct Config {
    host: String,   // ""
    puerto: u16,    // 0
    reintentos: u8, // 0
    tls: bool,      // false
}

fn main() {
    let c = Config::default();
    // ..Default::default() rellena el resto tras fijar solo lo que te importa
    let d = Config { puerto: 8080, tls: true, ..Default::default() };
    println!("{c:?}\n{d:?}");
}

La sintaxis ..Default::default() es idiomática: fijas los campos que te importan y dejas que el resto tome su valor por defecto. Default requiere que todos los campos sean Default, y sostiene patrones de todo el lenguaje: unwrap_or_default, mem::take, y el patrón builder.

#[derive(Default, Debug)]
enum Modo {
    #[default]
    Lectura,
    Escritura,
}