Rouille - Enums

Dans la programmation Rust, lorsque nous devons sélectionner une valeur dans une liste de variantes possibles, nous utilisons des types de données d'énumération. Un type énuméré est déclaré à l'aide du mot clé enum . Voici la syntaxe de enum -

enum enum_name {
   variant1,
   variant2,
   variant3
}

Illustration: utilisation d'une énumération

L'exemple déclare une énumération - GenderCategory , qui a des variantes comme Homme et Femme. L' impression! La macro affiche la valeur de l'énumération. Le compilateur lancera une erreur dont le trait std :: fmt :: Debug n'est pas implémenté pour GenderCategory . L'attribut # [derive (Debug)] est utilisé pour supprimer cette erreur.

// The `derive` attribute automatically creates the implementation
// required to make this `enum` printable with `fmt::Debug`.
#[derive(Debug)]
enum GenderCategory {
   Male,Female
}
fn main() {
   let male = GenderCategory::Male;
   let female = GenderCategory::Female;

   println!("{:?}",male);
   println!("{:?}",female);
}

Production

Male
Female

Struct et Enum

L'exemple suivant définit une structure Person. Le champ gender est du type GenderCategory (qui est une énumération) et peut être attribué à Male ou Female comme valeur.

// The `derive` attribute automatically creates the 
implementation
// required to make this `enum` printable with 
`fmt::Debug`.

#[derive(Debug)]
enum GenderCategory {
   Male,Female
}

// The `derive` attribute automatically creates the implementation
// required to make this `struct` printable with `fmt::Debug`.
#[derive(Debug)]
struct Person {
   name:String,
   gender:GenderCategory
}

fn main() {
   let p1 = Person {
      name:String::from("Mohtashim"),
      gender:GenderCategory::Male
   };
   let p2 = Person {
      name:String::from("Amy"),
      gender:GenderCategory::Female
   };
   println!("{:?}",p1);
   println!("{:?}",p2);
}

L'exemple crée des objets p1 et p2 de type Person et initialise les attributs, le nom et le sexe de chacun de ces objets.

Production

Person { name: "Mohtashim", gender: Male }
Person { name: "Amy", gender: Female }

Option Enum

Option est une énumération prédéfinie dans la bibliothèque standard Rust. Cette énumération a deux valeurs - Some (data) et None.

Syntaxe

enum Option<T> {
   Some(T),      //used to return a value
   None          // used to return null, as Rust doesn't support 
   the null keyword
}

Ici, le type T représente la valeur de tout type.

Rust ne prend pas en charge le mot clé null . La valeur None , dans enumOption , peut être utilisée par une fonction pour renvoyer une valeur nulle. S'il y a des données à renvoyer, la fonction peut renvoyer Some (data) .

Comprenons cela avec un exemple -

Le programme définit une fonction is_even () , avec un type de retour Option. La fonction vérifie si la valeur transmise est un nombre pair. Si l'entrée est paire, une valeur true est renvoyée, sinon la fonction renvoie None .

fn main() {
   let result = is_even(3);
   println!("{:?}",result);
   println!("{:?}",is_even(30));
}
fn is_even(no:i32)->Option<bool> {
   if no%2 == 0 {
      Some(true)
   } else {
      None
   }
}

Production

None
Some(true)

Énoncé de correspondance et énumération

L' instruction match peut être utilisée pour comparer des valeurs stockées dans une énumération. L'exemple suivant définit une fonction, print_size , qui prend CarType enum comme paramètre. La fonction compare les valeurs des paramètres avec un ensemble prédéfini de constantes et affiche le message approprié.

enum CarType {
   Hatch,
   Sedan,
   SUV
}
fn print_size(car:CarType) {
   match car {
      CarType::Hatch => {
         println!("Small sized car");
      },
      CarType::Sedan => {
         println!("medium sized car");
      },
      CarType::SUV =>{
         println!("Large sized Sports Utility car");
      }
   }
}
fn main(){
   print_size(CarType::SUV);
   print_size(CarType::Hatch);
   print_size(CarType::Sedan);
}

Production

Large sized Sports Utility car
Small sized car
medium sized car

Match avec option

L'exemple de la fonction is_even , qui retourne le type Option, peut également être implémenté avec l'instruction match comme indiqué ci-dessous -

fn main() {
   match is_even(5) {
      Some(data) => {
         if data==true {
            println!("Even no");
         }
      },
      None => {
         println!("not even");
      }
   }
}
fn is_even(no:i32)->Option<bool> {
   if no%2 == 0 {
      Some(true)
   } else {
      None
   }
}

Production

not even

Correspondance et énumération avec le type de données

Il est possible d'ajouter un type de données à chaque variante d'une énumération. Dans l'exemple suivant, les variantes Name et Usr_ID de l'énumération sont respectivement de type String et integer. L'exemple suivant montre l'utilisation de l'instruction match avec une énumération ayant un type de données.

// The `derive` attribute automatically creates the implementation
// required to make this `enum` printable with `fmt::Debug`.
#[derive(Debug)]
enum GenderCategory {
   Name(String),Usr_ID(i32)
}
fn main() {
   let p1 = GenderCategory::Name(String::from("Mohtashim"));
   let p2 = GenderCategory::Usr_ID(100);
   println!("{:?}",p1);
   println!("{:?}",p2);

   match p1 {
      GenderCategory::Name(val)=> {
         println!("{}",val);
      }
      GenderCategory::Usr_ID(val)=> {
         println!("{}",val);
      }
   }
}

Production

Name("Mohtashim")
Usr_ID(100)
Mohtashim