Respuesta

Pattern matching en Rust permite descomponer valores según su estructura, analizar y procesar tipos complejos mediante las construcciones match, if let, while let. La destructuración (descomposición en partes) es útil para trabajar con tuplas, estructuras, enums e incluso referencias.

Ejemplo con enum:

enum Message {
    Quit,
    ChangeColor(i32, i32, i32),
    Write(String),
}

let m = Message::ChangeColor(255, 0, 0);
match m {
    Message::Quit => println!("¡Salir!"),
    Message::ChangeColor(r, g, b) => println!("Color: {} {} {}", r, g, b),
    Message::Write(text) => println!("Texto: {}", text),
}

Destructuración de estructuras:

struct Point { x: i32, y: i32 }
let p = Point { x: 10, y: 20 };
let Point { x, y } = p;

Matices:

• Usar ref y ref mut permite obtener referencias al descomponer.
• Con @ se puede "renombrar" parte del patrón.
• Coincidencia por valores, rangos, condiciones (if guard).
• Al desestructurar referencias (&SomeType) es importante recordar la propiedad y el préstamo.

Pregunta capciosa

¿Se puede usar siempre "_" (guion bajo) para ignorar partes del patrón y evitar advertencias del compilador?

No siempre. El guion bajo realmente ignora el valor, pero si no se procesan todas las variantes del enum y se usa "_" como captura general, podrías perder el manejo de nuevas variantes al extender el enum en el futuro. ¡Es mejor enumerar siempre las variantes importantes explícitamente, para que el compilador advierta sobre los casos no considerados!

match result {
    Ok(val) => ..., 
    Err(err) => ..., 
    //_ => ... // ¡no recomendado para enums!
}

Ejemplos de errores reales debido al desconocimiento de los matices del tema

---

Historia

En una aplicación IoT, el dispositivo dejó de responder porque al agregar una nueva variante de enum en el lugar de pattern matching se usó la captura general "_". El error permaneció invisible hasta el despliegue. Después de eso, los enums críticos siempre se manejaron solo con un desglose explícito de variantes.

---

Historia

Para una estructura compleja con tuplas anidadas, olvidaron agregar la sintaxis de destructuración para campos recursivos, y en lugar de obtener referencias, los códigos clonaron accidentalmente grandes objetos, lo que llevó a una disminución en el rendimiento.

---

Historia

En una funcionalidad de transmisión de mensajes entre hilos, utilizaron la destructuración a través de if-let, pero ignoraron variantes raras del enum. Cuando apareció una nueva lógica empresarial, los mensajes simplemente se perdían. Después de eso, se estableció en el equipo la regla de que cada expresión match debe ser exhaustiva sin capturas generales.