Ruggine - Enums

Nella programmazione Rust, quando dobbiamo selezionare un valore da un elenco di possibili varianti, usiamo tipi di dati di enumerazione. Un tipo enumerato viene dichiarato utilizzando la parola chiave enum . La seguente è la sintassi di enum -

enum enum_name {
   variant1,
   variant2,
   variant3
}

Illustrazione: utilizzo di un'enumerazione

L'esempio dichiara un'enumerazione - GenderCategory , che ha varianti come Male e Female. La stampa! la macro mostra il valore dell'enumerazione. Il compilatore genererà un errore il tratto std :: fmt :: Debug non è implementato per GenderCategory . L'attributo # [derive (Debug)] viene utilizzato per eliminare questo errore.

// 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);
}

Produzione

Male
Female

Struct ed Enum

L'esempio seguente definisce una struttura Person. Il campo sesso è del tipo GenderCategory (che è un'enumerazione ) e può essere assegnato a Male o Female come valore.

// 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'esempio crea oggetti p1 e p2 di tipo Persona e inizializza gli attributi, il nome e il sesso per ciascuno di questi oggetti.

Produzione

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

Opzione Enum

Option è un'enumerazione predefinita nella libreria standard di Rust. Questa enumerazione ha due valori: Some (data) e None.

Sintassi

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

Qui, il tipo T rappresenta il valore di qualsiasi tipo.

Rust non supporta la parola chiave null . Il valore None , in enumOption , può essere utilizzato da una funzione per restituire un valore null. Se sono presenti dati da restituire, la funzione può restituire Some (data) .

Facci capire questo con un esempio:

Il programma definisce una funzione is_even () , con un tipo di ritorno Option. La funzione verifica se il valore passato è un numero pari. Se l'input è pari, viene restituito un valore true, altrimenti la funzione restituisce 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
   }
}

Produzione

None
Some(true)

Match Statement ed Enum

L' istruzione match può essere utilizzata per confrontare i valori archiviati in un enum. L'esempio seguente definisce una funzione, print_size , che accetta CarType enum come parametro. La funzione confronta i valori dei parametri con un insieme predefinito di costanti e visualizza il messaggio appropriato.

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);
}

Produzione

Large sized Sports Utility car
Small sized car
medium sized car

Abbina con Opzione

L'esempio della funzione is_even , che restituisce il tipo di opzione, può anche essere implementato con l'istruzione match come mostrato di seguito -

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
   }
}

Produzione

not even

Abbina ed enum con il tipo di dati

È possibile aggiungere un tipo di dati a ciascuna variante di un enum. Nell'esempio seguente, le varianti Name e Usr_ID dell'enumerazione sono rispettivamente di tipo String e integer. L'esempio seguente mostra l'uso dell'istruzione match con un'enumerazione con un tipo di dati.

// 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);
      }
   }
}

Produzione

Name("Mohtashim")
Usr_ID(100)
Mohtashim