Enums - Rust By Example
Description: Rust by Example (RBE) is a collection of runnable examples that illustrate various Rust concepts and standard libraries.

## Keyboard shortcuts

Press `←` or `→` to navigate between chapters

Press `S` or `/` to search in the book

Press `?` to show this help

Press `Esc` to hide this help

# 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