Enums

La palabra clave enum permite la creación de un tipo que puede ser uno de unas pocasdiferentes variantes. Cualquier variante que sea válida como struct también es válidaen un enum.

// Cree un `enum` para clasificar un evento web. Tenga en cuenta cómo ambos los
// nombres y los tipos juntos especifican la variante:
// `PageLoad != PageUnload` y `KeyPress(char) != Paste(String)`.
// Cada uno es diferente e independiente.
enum WebEvent {
    // Una variante `enum` puede ser `cuasi-unitaria`,
    PageLoad,
    PageUnload,
    // como estructuras de tuplas    KeyPress(char),
    Paste(String),
    // o estructuras estilo C.
    Click { x: i64, y: i64 },
}

// Una función que toma un enum 'WebEvent` como argumento y 
// no devuelve nada.
fn inspect(event: WebEvent) {
    match event {
        WebEvent::PageLoad => println!("página cargada"),
        WebEvent::PageUnload => println!("página descargada "),
        // Destructura `c` desde dentro de la variante `enum`.
        WebEvent::KeyPress(c) => println!("presionaste '{}'.", c),
        WebEvent::Paste(s) => println!("pegaste \"{}\".", s),
        // Destructura `Click` en `x` y `y`.
        WebEvent::Click { x, y } => {
            println!("click en x={}, y={}.", x, y);
        },
    }
}

fn main() {
    let pressed = WebEvent::KeyPress('x');
    // `to_owned()` crea un `String` que es owned de slice de cadena.
    let pasted  = WebEvent::Paste("mi texto".to_owned());
    let click   = WebEvent::Click { x: 20, y: 80 };
    let load    = WebEvent::PageLoad;
    let unload  = WebEvent::PageUnload;

    inspect(pressed);
    inspect(pasted);
    inspect(click);
    inspect(load);
    inspect(unload);
}

Aliases de tipos

Si usa un alias de tipo, puedes consultar cada variante de enum a través de su alias.Esto podría ser útil si el nombre del enum es demasiado largo o demasiado genérico, y lo quieres renombrar.

enum VeryVerboseEnumOfThingsToDoWithNumbers {
    Add,
    Subtract,
}

// Crear un alias de tipo
type Operations = VeryVerboseEnumOfThingsToDoWithNumbers;

fn main() {
    // Podemos referirnos a cada variante a través de su alias, y no su largo einconveniente 
   // nombre. 
    let x = Operations::Add;
}

El lugar más común que verás esto es en los bloques de impl usando el alias Self .

enum VeryVerboseEnumOfThingsToDoWithNumbers {
    Add,
    Subtract,
}

impl VeryVerboseEnumOfThingsToDoWithNumbers {
    fn run(&self, x: i32, y: i32) -> i32 {
        match self {
            Self::Add => x + y,
            Self::Subtract => x - y,
        }
    }
}

Para obtener más información sobre enums y alias de tipo, puedes leer el informe estabilización de cuando este feature se estabilizó en Rust.

Ver también

match, fn, y String, "Type alias enum variants" RFC