match: el pattern matching

Si tuvieras que quedarte con una sola construcción de Rust, muchos elegirían match. Aparenta ser el switch de C, pero es otra especie: no compara igualdad contra constantes, sino que descompone un valor contra patrones, liga partes de él a variables, y —el rasgo decisivo— exige que cubras todos los casos posibles o no compila. Esa exhaustividad convierte “¿habré manejado todas las variantes?” de una duda en tiempo de ejecución a una garantía en tiempo de compilación.

match como expresión

match compara un valor contra una serie de brazos, cada uno un patrón y un cuerpo separados por =>. Se ejecuta el primero que encaja, y su cuerpo es el valor de todo el match:

let dado = 4;
let texto = match dado {
    1 => "uno",
    2 => "dos",
    3 | 4 | 5 => "en medio",     // or-pattern: varios valores, un brazo
    6 => "seis",
    _ => "imposible en un dado", // comodín: captura el resto
};

Como es una expresión, todos los brazos deben producir el mismo tipo (aquí, &str), igual que las ramas de un if. El comodín _ encaja con cualquier cosa y no liga nombre; es la vía de escape para “todo lo demás”.

La exhaustividad no es opcional

Aquí match se separa del switch. El compilador comprueba que los patrones cubren todos los valores posibles del tipo. Si te dejas uno, es un error, no un aviso:

let n: u8 = 200;
match n {
    0 => println!("cero"),
    1..=255 => println!("resto"),
} // OK: 0 y 1..=255 cubren todos los u8

match n {
    0 => println!("cero"),
    // ERROR E0004: non-exhaustive patterns: `1..=255` not covered
}

Esto brilla con los enum. Imagina un enum Semaforo { Rojo, Ambar, Verde }. Un match sobre él debe tratar las tres variantes. Y si mañana alguien añade una cuarta, Semaforo::Intermitente, todos los match que no la contemplen dejarán de compilar, señalándote exactamente dónde has de decidir qué hacer con el caso nuevo:

enum Semaforo { Rojo, Ambar, Verde }

fn accion(s: Semaforo) -> &'static str {
    match s {
        Semaforo::Rojo => "parar",
        Semaforo::Ambar => "precaucion",
        Semaforo::Verde => "avanzar",
    } // exhaustivo: quita un brazo y no compila
}

La verdadera potencia llega cuando las variantes llevan datos: match los extrae en el mismo gesto con que distingue la variante, algo que ningún switch puede hacer.

enum Evento {
    Clic { x: i64, y: i64 },
    Tecla(char),
    Cerrar,
}

fn describir(e: Evento) -> String {
    match e {
        Evento::Clic { x, y } => format!("clic en {x},{y}"),
        Evento::Tecla(c) => format!("tecla {c}"),
        Evento::Cerrar => "cerrar".to_string(),
    }
}

Patrones: un sublenguaje entero

Lo que va a la izquierda de => no es un valor: es un patrón, y los patrones forman un pequeño lenguaje propio. Pueden descomponer estructuras, ligar partes a variables, filtrar por rango y añadir condiciones extra:

let punto = (0, -7);
let donde = match punto {
    (0, 0) => "origen".to_string(),
    (x, 0) => format!("eje X en {x}"),          // liga x, exige y == 0
    (0, y) => format!("eje Y en {y}"),          // liga y, exige x == 0
    (x, y) if x == y => "diagonal".to_string(), // GUARDA: condición extra
    (x, y) => format!("libre en {x},{y}"),      // liga ambos
};

Los ingredientes que acabas de ver:

El enlace con @ merece un ejemplo, porque une comprobar y capturar en un solo gesto:

let edad = 25;
match edad {
    n @ 0..=17 => println!("menor, {n} años"),
    n @ 18..=64 => println!("adulto, {n} años"),
    n => println!("mayor, {n} años"),
}

Un último detalle ergonómico: al hacer match sobre una referencia, Rust ajusta los enlaces para que presten en vez de mover. Matchear &Some(x) liga x como &T sin que tengas que escribir ref a mano.

let texto = Some(String::from("hola"));
match &texto {
    Some(s) => println!("{} letras", s.len()), // s: &String, no mueve
    None => {}
}
// `texto` sigue disponible aquí: el match solo prestó