La expresión match en Rust es una herramienta de control de flujo que permite comparar un valor contra una serie de patrones. A diferencia de otras estructuras como el switch de otros lenguajes, el match de Rust destaca por ser exhaustivo. Esto significa que el compilador te obliga a manejar absolutamente todos los casos posibles de un tipo de dato. Si estás evaluando un enum con tres variantes y solo escribes lógica para dos, el compilador detectará el caso faltante y generará un error de compilación, impidiendo que el programa se ejecute de forma insegura.

Esta característica es fundamental para la seguridad de la memoria y la lógica de software, ya que evita el error común de olvidar tratar un estado específico (como un error de red o un valor nulo). Para facilitar este proceso, Rust ofrece el patrón comodín _ (wildcard), que actúa como un “atrapa-todo” para cualquier valor que no haya coincidido con los patrones anteriores. Además, match es una expresión, lo que significa que puede devolver un valor para ser asignado a una variable, siempre que todos los brazos del match devuelvan el mismo tipo de dato.

enum Estado {
    Activo,
    Inactivo,
    Suspendido,
}

fn procesar_estado(estado: Estado) -> &'static str {
    // El match debe ser exhaustivo para todos los variantes de Estado
    match estado {
        Estado::Activo => "El sistema está operando.",
        // Uso de '|' para combinar múltiples patrones en un solo brazo
        Estado::Inactivo | Estado::Suspendido => "El sistema está detenido.",
    }
}

fn main() {
    // Ejemplo de match con un enum personalizado
    let mi_estado = Estado::Suspendido;
    let mensaje_estado = procesar_estado(mi_estado);
    println!("Estado actual: {}", mensaje_estado);

    // Ejemplo de match como expresión con rangos y comodín
    let numero = 10;
    let categoria = match numero {
        1..=5 => "Número pequeño",       // Rango inclusivo
        6 | 7 | 8 => "Número medio",     // Múltiples valores literales
        _ => "Número grande o cualquier otro", // El comodín 'wildcard' cubre el resto
    };
    
    println!("La categoría de {} es: {}", numero, categoria);
}

Explicación del Código

  • enum Estado: Define un tipo enumerado con tres variantes: Activo, Inactivo y Suspendido.
  • fn procesar_estado(estado: Estado) -> &'static str: Una función que recibe un tipo Estado y devuelve una referencia estática a una cadena de texto (&'static str).
  • match estado: Dentro de procesar_estado, evaluamos la variable estado.
  • Estado::Activo: El primer brazo que coincide si el valor es la variante Activo.
  • Estado::Inactivo | Estado::Suspendido: Utiliza el operador | para agrupar dos patrones; si estado es cualquiera de los dos, se ejecuta este brazo. Como se cubrieron las tres variantes del enum, el match es exhaustivo.
  • let mi_estado = Estado::Suspendido: En main, creamos una instancia de Estado.
  • let mensaje_estado = procesar_estado(mi_estado): Llamamos a la función y asignamos el resultado a mensaje_estado.
  • let numero = 10: Una variable entera para el segundo ejemplo.
  • let categoria = match numero { ... }: Aquí match se usa como una expresión para asignar un valor directamente a categoria.
  • 1..=5: Un patrón de rango que captura cualquier número entre 1 y 5 inclusive.
  • 6 | 7 | 8: Captura específicamente los literales 6, 7 u 8.
  • _: El patrón comodín que captura cualquier otro valor (en este caso, cualquier i32 que no sea 1, 2, 3, 4, 5, 6, 7 u 8), asegurando que el match sea exhaustivo para el tipo i32.

N° 40