Créer une chaîne Enum dans Rust

1. Créer des énumérations dans Rust
2. Strum dans Rust

Dans cet article, nous allons apprendre à créer une chaîne enum dans Rust.

Créer des énumérations dans Rust

Dans Rust, une énumération représente des données qui sont l’une des multiples versions possibles. Le mot-clé enum permet de développer un type qui peut être l’une de plusieurs versions possibles.

Toute version valide en tant que struct est également valide en tant que enum. De plus, chaque version dans enum peut éventuellement avoir des données liées :

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

Il existe des variantes sans données, des variantes avec des données nommées et des variantes avec des données anonymes. La syntaxe de définition des variantes imite celle de la définition de structures telles que les tuple structs.

Contrairement aux définitions de structures individuelles, un enum est un type unique. Une valeur enum peut correspondre à n’importe laquelle des variantes.

C’est pourquoi un enum est fréquemment appelé un type somme : l’ensemble des valeurs enum potentielles est la somme des ensembles de valeurs variantes possibles.

Nous utilisons la syntaxe :: pour faire référence au nom de chaque variante, qui est délimité par le nom de enum lui-même.

Strum dans Rust

Strum est une collection de macros et de caractéristiques qui facilitent le travail avec les enums et les chaînes dans Rust.

EnumString : dérive automatiquement std::str::FromStr est appliqué à enum. Chaque version enum correspondra à son nom.

Cela peut être remplacé en utilisant serialize="DifferentName" ou string="DifferentName" sur l’attribut, comme illustré ci-dessous. Il est possible d’ajouter plusieurs désérialisations à une même variation.

Si la variation contient des données supplémentaires, la désérialisation les définira sur leurs valeurs par défaut. L’attribut default peut être appliqué à une variation de tuple avec un seul paramètre de données.

La variante spécifiée est renvoyée si aucune correspondance n’est découverte et la chaîne d’entrée est capturée en tant que paramètre. Voici un exemple de code créé par héritage EnumString.

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

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

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

Notez que l’implémentation par défaut de FromStr ne correspond qu’au nom de la variante. Display et ToString renvoient tous deux la variation enum spécifiée. Cela vous permet de convertir des variantes de style unité de enum en chaîne et inversement.

De plus, ToString et Display sélectionnent la sérialisation appropriée en fonction des critères suivants.

1. Cette valeur sera utilisée si une propriété de chaîne existe. Un seul est autorisé par version.
2. La propriété sérialisée avec la valeur la plus longue est sélectionnée. Si ce comportement n’est pas souhaité, utilisez to string à la place.
3. Enfin, le nom de la variante sera utilisé s’il n’existe aucune propriété serialize ou to string n’existe.

Display est préférable à ToString Tous les types implémentant ::std::fmt::Display ont une implémentation par défaut 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(); }