Structs y enums genéricos
Cree tipos de datos flexibles
Structs y enums genéricos es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.
Estructuras de datos genéricas
Al igual que las funciones, las structs y los enums pueden ser genéricos respecto a uno o varios tipos. Esto permite que una sola definición almacene valores de cualquier tipo.
La biblioteca estándar está construida de esta forma: Vec<T>, Option<T> y Result<T, E> son genéricos.
Una struct genérica
Declare el parámetro de tipo después del nombre de la struct y úselo en los campos. Aquí, Point almacena dos valores del mismo tipo T.
Una sola definición sirve ahora para puntos enteros, puntos de coma flotante y mucho más.
struct Point<T> {
x: T,
y: T,
}Construir structs genéricas
Al crear una instancia, el compilador infiere T a partir de los valores de los campos. Ambos campos deben tener el mismo tipo.
Este programa construye un punto entero y un punto de coma flotante a partir de la misma struct.
struct Point<T> {
x: T,
y: T,
}
fn main() {
let a = Point { x: 1, y: 2 };
let b = Point { x: 1.5, y: 4.0 };
println!("{} {}", a.x, b.y);
}Parámetros de tipos distintos
Usar dos parámetros permite que los campos sean diferentes. Pair<T, U> puede contener un entero y una cadena al mismo tiempo.
Elija un solo parámetro cuando los campos deban coincidir, y varios cuando puedan variar.
struct Pair<T, U> {
first: T,
second: U,
}Métodos en structs genéricas
Para añadir métodos, repita el parámetro de tipo en el bloque impl: impl<T> Point<T>. El parámetro después de impl lo declara; después del nombre del tipo, lo aplica.
Aquí, un getter devuelve una referencia al campo x.
struct Point<T> {
x: T,
y: T,
}
impl<T> Point<T> {
fn x(&self) -> &T {
&self.x
}
}Métodos con límites
Puede escribir métodos solo para ciertos tipos concretos o para tipos que cumplan un límite. Este impl se aplica únicamente a Point<f64>.
Por tanto, dist_from_origin existe en los puntos de coma flotante, pero no en los puntos enteros.
struct Point<T> { x: T, y: T }
impl Point<f64> {
fn dist_from_origin(&self) -> f64 {
(self.x * self.x + self.y * self.y).sqrt()
}
}Un enum genérico
Los enums también pueden ser genéricos. Cada variante puede contener datos genéricos. Esto refleja el Option estándar, que es Some(T) o None.
Definir uno propio le ayuda a entender cómo funciona el tipo de la biblioteca.
enum Maybe<T> {
Just(T),
Nothing,
}Dos parámetros en un enum
Result usa dos parámetros para que los valores de éxito y error puedan ser diferentes. Esta es una versión simplificada.
Los múltiples parámetros de tipo en los enums permiten un manejo flexible de errores en todo el ecosistema.
enum Either<L, R> {
Left(L),
Right(R),
}Coincidencia de enums genéricos
Puede hacer pattern matching con enums genéricos exactamente igual que con enums concretos. El contenido de la variante se convierte en una binding dentro del brazo.
Este programa desempaqueta un Maybe personalizado e imprime el valor contenido o un valor alternativo.
enum Maybe<T> { Just(T), Nothing }
fn main() {
let m: Maybe<i32> = Maybe::Just(5);
match m {
Maybe::Just(n) => println!("got {}", n),
Maybe::Nothing => println!("empty"),
}
}Envolver un valor
Un patrón habitual es una struct envoltorio con un campo de tipo T y métodos auxiliares. Aquí, Wrapper almacena y devuelve cualquier valor.
Esta es la base de los patrones newtype y de los tipos similares a punteros inteligentes.
struct Wrapper<T> { inner: T }
impl<T> Wrapper<T> {
fn new(v: T) -> Self {
Wrapper { inner: v }
}
}
fn main() {
let w = Wrapper::new("hi");
println!("{}", w.inner);
}Sin sobrecoste en tiempo de ejecución
Las structs y los enums genéricos también se monomorfizan. Point<i32> y Point<f64> se convierten en dos tipos distintos y completamente especializados después de la compilación.
No hay ninguna indirección ni etiqueta oculta para el tipo genérico en sí.
Comprobación rápida
Compruebe su comprensión de las structs y los enums genéricos.
Repaso
Las structs y los enums declaran parámetros de tipo después de su nombre y los usan en campos y variantes, lo que permite crear contenedores reutilizables como Option y Result.
Los métodos repiten los parámetros en impl<T>, y puede escribir bloques impl especializados para tipos concretos. Todo se monomorfiza para evitar cualquier sobrecoste.
Preguntas frecuentes
¿La lección «Structs y enums genéricos» es gratis?
Sí — el texto completo de «Structs y enums genéricos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.
¿Qué aprenderé en «Structs y enums genéricos»?
Cree tipos de datos flexibles Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Learn Rust Coding?
No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «Structs y enums genéricos»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?
Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Funciones genéricas
- Structs y enums genéricos
- Límites de traits
- Cláusulas where y múltiples límites