Crear enumeración de cadenas en Rust

1. Crear enumeraciones en Rust
2. Rasgueo en Rust

En este artículo, aprenderemos a crear una enumeración de cadenas en Rust.

Crear enumeraciones en Rust

En Rust, un enum representa datos que son una de las múltiples versiones posibles. La palabra clave enum permite el desarrollo de un tipo que puede ser una de varias versiones posibles.

Cualquier versión válida como estructura también es válida como enum. Además, cada versión en el enum puede tener opcionalmente datos relacionados:

enum Information {
    Quit,
    ChangeColor(i32, i32, i32),
    Move { x: i32, y: i32 },
    Write(String),
}

Hay variaciones sin datos, variantes con datos con nombre y variantes con datos anónimos. La sintaxis para definir variantes imita la de definir estructuras como estructuras de tupla.

A diferencia de las definiciones de estructuras individuales, una enumeración es un tipo único. Un valor enum puede coincidir con cualquiera de las variantes.

Esta es la razón por la que una enumeración se denomina con frecuencia un tipo de suma: el conjunto de valores potenciales de enumeración es la suma de los conjuntos de posibles valores variantes.

Usamos la sintaxis :: para referirnos al nombre de cada variante, cuyo ámbito está definido por el nombre de la propia enum.

Rasgueo en Rust

Strum es una colección de macros y características que facilitan el trabajo con enum y cadenas en Rust.

EnumString: deriva automáticamente std::str::FromStr se aplica a enum. Cada versión enum coincidirá con su nombre.

Esto se puede anular usando serialize="DifferentName" o string="DifferentName" en el atributo, como se muestra a continuación. Es posible agregar muchas deserializaciones a la misma variación.

Si la variación contiene datos adicionales, la deserialización los establecerá en sus valores predeterminados. El atributo default se puede aplicar a una variación de tupla con un solo parámetro de datos.

La variante especificada se devuelve si no se descubre ninguna coincidencia y la cadena de entrada se captura como un parámetro. Aquí hay un ejemplo de código creado por la herencia EnumString.

#[derive(EnumString)]
enum Cars {
    BMW,
    Volvo { range:usize },

    #[strum(serialize="Toyota",serialize="b")]
    Toyota(usize),

    #[strum(disabled="true")]
    Fiat,
}

Tenga en cuenta que la implementación predeterminada de FromStr solo coincide con el nombre de la variante. Tanto Display como ToString devuelven la variación enum especificada. Esto le permite convertir variantes de estilo de unidad de enum a cadena y viceversa.

Además, ToString y Display seleccionan la serialización adecuada según los siguientes criterios.

1. Este valor se utilizará si existe una propiedad de cadena. Solo se permite uno por versión.
2. Se selecciona la propiedad serializada con el valor más largo. Si no se desea este comportamiento, use para enhebrar en su lugar.
3. Finalmente, se utilizará el nombre de la variante si no existen las propiedades serialize ni to string.

Display es preferible a ToString. Todos los tipos que implementan ::std::fmt::Display tienen una implementación predeterminada de ToString.

use std::string::ToString;

#[derive(Display, Debug)]
enum Cars {
    #[strum(serialize="redred")]
    BMW,
    Volvo { range:usize },
    Toyota(usize),
    Ferrari,
}

fn debug_cars() {
    let BMW = Cars::BMW;
    assert_eq!(String::from("BMWBMW"), BMW.to_string());
}

fn main () { debug_cars(); }