Que son los structs y los enums

 Los structs y los enums son dos formas de definir tipos de datos personalizados en Rust.

Un **struct** es una forma de agrupar varios campos de diferentes tipos en un solo tipo compuesto. Los structs se pueden usar para representar conceptos o entidades que tienen propiedades o atributos asociados. Por ejemplo, se puede definir un struct para representar un punto en el espacio bidimensional:

struct Punto {

    x: f64, // campo x de tipo f64

    y: f64, // campo y de tipo f64

}

Para crear una instancia de un struct, se usa la sintaxis Nombre { campo: valor, ... }. Por ejemplo:

let p = Punto { x: 3.0, y: 4.0 }; // crea un punto con las coordenadas (3.0, 4.0)

Para acceder o modificar los campos de un struct, se usa la notación de punto .. Por ejemplo:

println!("El punto está en ({}, {})", p.x, p.y); // imprime los valores de los campos x e y del punto p

p.x = 5.0; // cambia el valor del campo x del punto p a 5.0

Los structs también pueden tener métodos asociados, que son funciones que operan sobre una instancia de un struct. Para definir un método, se usa la palabra clave impl seguida del nombre del struct y un bloque que contiene las definiciones de los métodos. Por ejemplo:

impl Punto {

    // define un método llamado distancia que recibe una referencia inmutable a otro punto y devuelve un f64

    fn distancia(&self, otro: &Punto) -> f64 {

        // calcula la distancia euclidiana entre dos puntos usando el teorema de Pitágoras

        ((self.x - otro.x).powi(2) + (self.y - otro.y).powi(2)).sqrt()

    }

}

Para llamar a un método, se usa la notación de punto . seguida del nombre del método y los argumentos entre paréntesis. Por ejemplo:

let q = Punto { x: 0.0, y: 0.0 }; // crea otro punto con las coordenadas (0.0, 0.0)

let d = p.distancia(&q); // llama al método distancia con el argumento q y guarda el resultado en una variable d

println!("La distancia entre los puntos es {}", d); // imprime el valor de d

Un **enum** es una forma de definir un tipo de dato que puede ser uno de varios valores posibles. Cada valor posible se llama una variante del enum. Los enums se pueden usar para representar opciones o alternativas que son mutuamente excluyentes. Por ejemplo, se puede definir un enum para representar el estado de ánimo de una persona:

enum EstadoDeAnimo {

    Alegre, // variante Alegre sin datos asociados

    Triste, // variante Triste sin datos asociados

    Enojado { nivel: u8 }, // variante Enojado con un campo nivel de tipo u8

    Confundido(String), // variante Confundido con un dato asociado de tipo String

}

Para crear una instancia de un enum, se usa la sintaxis Nombre::Variante o Nombre::Variante(dato) si la variante tiene datos asociados. Por ejemplo:

let e1 = EstadoDeAnimo::Alegre; // crea una instancia del enum con la variante Alegre

let e2 = EstadoDeAnimo::Enojado { nivel: 5 }; // crea una instancia del enum con la variante Enojado y el nivel 5

let e3 = EstadoDeAnimo::Confundido("¿Qué pasa?".to_string()); // crea una instancia del enum con la variante Confundido y el dato "¿Qué pasa?"

Para acceder o modificar los datos asociados a una variante de un enum, se usa la coincidencia de patrones con la expresión match o la expresión if let. Por ejemplo:

match e2 {

    EstadoDeAnimo::Alegre => println!("Estoy feliz"), // si e2 es Alegre, imprime un mensaje

    EstadoDeAnimo::Triste => println!("Estoy triste"), // si e2 es Triste, imprime otro mensaje

    EstadoDeAnimo::Enojado { nivel } => println!("Estoy enojado al nivel {}", nivel), // si e2 es Enojado, imprime el nivel

    EstadoDeAnimo::Confundido(mensaje) => println!("Estoy confundido: {}", mensaje), // si e2 es Confundido, imprime el mensaje

}


if let EstadoDeAnimo::Confundido(mensaje) = e3 {

    println!("Estoy confundido: {}", mensaje); // si e3 es Confundido, imprime el mensaje

} else {

    println!("No estoy confundido"); // si e3 no es Confundido, imprime otro mensaje

}

Los enums también pueden tener métodos asociados, de la misma forma que los structs. Por ejemplo:

impl EstadoDeAnimo {

    // define un método llamado describir que recibe una referencia inmutable a una instancia del enum y devuelve un String

    fn describir(&self) -> String {

        match self {

            EstadoDeAnimo::Alegre => "Estoy feliz".to_string(), // si self es Alegre, devuelve un String con el mensaje

            EstadoDeAnimo::Triste => "Estoy triste".to_string(), // si self es Triste, devuelve otro String con otro mensaje

            EstadoDeAnimo::Enojado { nivel } => format!("Estoy enojado al nivel {}", nivel), // si self es Enojado, devuelve un String con el nivel

            EstadoDeAnimo::Confundido(mensaje) => format!("Estoy confundido: {}", mensaje), // si self es Confundido, devuelve un String con el mensaje

        }

    }

}

Para llamar a un método de un enum, se usa la misma notación de punto . que para los structs. Por ejemplo:

let descripcion = e1.describir(); // llama al método describir y guarda el resultado en una variable descripcion

println!("{}", descripcion); // imprime el valor de descripcion

Espero que esta explicación te haya sido útil. Si quieres aprender más sobre los structs y los enums en Rust, te recomiendo que visites los siguientes enlaces:

[Struct y enum en Rust: ¿Qué son y en qué se diferencian?](https://unpinguino.net/posts/struct-y-enum-en-rust-que-son-y-en-que-se-diferencian/)

[Rust - Definición de un Enum](https://runebook.dev/es/docs/rust/book/ch06-01-defining-an-enum)

[Rust - Enumeración y coincidencia de patrones](https://runebook.dev/es/docs/rust/book/ch06-00-enums)

Comentarios

Entradas populares de este blog

Como actualizar Rust

Tipos de Datos en Rust

El comando "rustc"