Enums y Pattern Matching

Un enum define un tipo como una de varias variantes con nombre. A diferencia de los enums de muchos lenguajes, que son solo números etiquetados, los de Rust se pueden hacer match de forma exhaustiva, e incluso cada variante puede llevar sus propios datos.

enum Direction {
    Up,
    Down,
    Left,
    Right,
}

fn describe(dir: Direction) -> &'static str {
    match dir {
        Direction::Up => "going up",
        Direction::Down => "going down",
        Direction::Left => "going left",
        Direction::Right => "going right",
    }
}

fn main() {
    println!("{}", describe(Direction::Left));
}

going left

match compara un valor contra cada variante por turno, y el compilador comprueba que cada variante posible está cubierta — deja una fuera, y será un error de compilación, no un error esperando ocurrir en tiempo de ejecución.

Enums que llevan datos

Cada variante de un enum puede contener sus propios datos con su propia forma — Shape::Circle lleva un único f64, mientras que Shape::Rectangle lleva dos. match desestructura la variante que esté realmente presente, vinculando sus datos a un nombre que puedes usar directamente.

enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
}

fn area(shape: Shape) -> f64 {
    match shape {
        Shape::Circle(radius) => 3.14159 * radius * radius,
        Shape::Rectangle(w, h) => w * h,
    }
}

fn main() {
    println!("{:.2}", area(Shape::Circle(2.0)));
    println!("{:.2}", area(Shape::Rectangle(3.0, 4.0)));
}

12.57
12.00

Siguiente: Option y Result — cómo Rust reemplaza null y las excepciones con dos enums comunes.