Rust - enumeraciones

En la programación de Rust, cuando tenemos que seleccionar un valor de una lista de posibles variantes, usamos tipos de datos de enumeración. Un tipo enumerado se declara mediante la palabra clave enum . A continuación se muestra la sintaxis de enum:

enum enum_name {
   variant1,
   variant2,
   variant3
}

Ilustración: uso de una enumeración

El ejemplo declara una enumeración: GenderCategory , que tiene variantes como Masculino y Femenino. ¡La impresión! macro muestra el valor de la enumeración. El compilador arrojará un error: el rasgo std :: fmt :: Debug no está implementado para GenderCategory . El atributo # [derivar (depurar)] se usa para suprimir este error.

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

Salida

Male
Female

Estructura y enumeración

El siguiente ejemplo define una estructura Person. El campo género es del tipo GenderCategory (que es una enumeración) y se puede asignar como valor Masculino o Femenino .

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

El ejemplo crea objetos p1 y p2 de tipo Person e inicializa los atributos, el nombre y el género de cada uno de estos objetos.

Salida

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

Opción Enum

Option es una enumeración predefinida en la biblioteca estándar de Rust. Esta enumeración tiene dos valores: Algunos (datos) y Ninguno.

Sintaxis

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

Aquí, el tipo T representa valor de cualquier tipo.

Rust no admite la palabra clave nula . Una función puede utilizar el valor None , en enumOption , para devolver un valor nulo. Si hay datos para devolver, la función puede devolver Algunos (datos) .

Entendamos esto con un ejemplo:

El programa define una función is_even () , con un tipo de retorno Option. La función verifica si el valor pasado es un número par. Si la entrada es par, se devuelve un valor verdadero; de lo contrario, la función devuelve 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
   }
}

Salida

None
Some(true)

Declaración de coincidencia y enumeración

La declaración de coincidencia se puede utilizar para comparar valores almacenados en una enumeración. El siguiente ejemplo define una función, print_size , que toma CarType enum como parámetro. La función compara los valores de los parámetros con un conjunto predefinido de constantes y muestra el mensaje correspondiente.

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

Salida

Large sized Sports Utility car
Small sized car
medium sized car

Coincidir con opción

El ejemplo de la función is_even , que devuelve el tipo de opción, también se puede implementar con la declaración de coincidencia como se muestra a continuación:

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

Salida

not even

Coincidir y enumerar con tipo de datos

Es posible agregar tipo de datos a cada variante de una enumeración. En el siguiente ejemplo, las variantes Name y Usr_ID de la enumeración son de tipo String y entero, respectivamente. El siguiente ejemplo muestra el uso de la declaración de coincidencia con una enumeración que tiene un tipo de datos.

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

Salida

Name("Mohtashim")
Usr_ID(100)
Mohtashim