Nivel 2 · Practicante· Lección 1 de 8 · 20 min
Genéricos
Escribir el código una sola vez para muchos tipos, cómo la monomorfización hace que no cueste nada en tiempo de ejecución, y los genéricos constantes.
El problema que resuelven los genéricos
fn largest_i32(xs: &[i32]) -> i32 {
let mut max = xs[0];
for &x in xs {
if x > max { max = x; }
}
max
}
fn main() {
println!("{}", largest_i32(&[3, 9, 2]));
}
Para admitir f64 o char tendrías que copiar la función y cambiar una palabra. Los genéricos te permiten escribirla una sola vez:
fn largest<T: PartialOrd + Copy>(xs: &[T]) -> T {
let mut max = xs[0];
for &x in xs {
if x > max { max = x; }
}
max
}
fn main() {
println!("{}", largest(&[3, 9, 2]));
println!("{}", largest(&[1.5, 0.2]));
println!("{}", largest(&['x', 'b']));
}
<T: PartialOrd + Copy> declara un parámetro de tipo con restricciones de trait (trait bounds): T puede ser cualquier tipo que admita la comparación de orden y la copia bit a bit. Quita las restricciones y el compilador se niega: el cuerpo de una función genérica se comprueba una sola vez, usando únicamente lo que prometen las restricciones. Esto es distinto de las plantillas de C++, que se comprueban en cada uso; en Rust, si la función genérica compila, compila para todo T que cumpla las restricciones.
Structs y enums genéricos
#[derive(Debug)]
struct Point<T> {
x: T,
y: T,
}
impl<T> Point<T> {
fn new(x: T, y: T) -> Self {
Point { x, y }
}
}
// Métodos solo para ciertos argumentos de tipo:
impl Point<f64> {
fn distance_from_origin(&self) -> f64 {
(self.x * self.x + self.y * self.y).sqrt()
}
}
fn main() {
let a = Point::new(1, 2);
let b = Point::new(3.0, 4.0);
println!("{a:?} {b:?} {}", b.distance_from_origin());
// a.distance_from_origin(); // ❌ ese método no existe en Point<i32>
}
Ya usas enums genéricos constantemente: Option<T> y Result<T, E> están definidos en la biblioteca estándar exactamente como los definirías tú.
Cláusulas where
Cuando las restricciones se alargan, muévelas después de la firma:
use std::fmt::Debug;
use std::collections::HashMap;
use std::hash::Hash;
fn count<T, I>(items: I) -> HashMap<T, usize>
where
T: Eq + Hash,
I: IntoIterator<Item = T>,
{
let mut map = HashMap::new();
for item in items {
*map.entry(item).or_insert(0) += 1;
}
map
}
fn show<T>(label: &str, value: T)
where
T: Debug,
{
println!("{label}: {value:?}");
}
fn main() {
show("letters", count("mississippi".chars()).get(&'s'));
show("numbers", count(vec![1, 1, 2]).len());
}
Monomorfización: genéricos de coste cero
Cuando llamas a largest con i32 y con f64, el compilador genera dos funciones, como si hubieras escrito a mano largest_i32 y largest_f64. Esto es la monomorfización.
- Ventaja: no hay despacho en tiempo de ejecución ni boxing, y todo se puede expandir en línea. El código genérico es tan rápido como el especializado a mano.
- Coste: tiempos de compilación más largos y binarios más grandes cuando una función genérica se instancia con muchos tipos.
La alternativa —una única copia compilada que trabaja a través de un puntero y una tabla de funciones— es el despacho dinámico con dyn Trait, que se trata en el nivel 3.
Genéricos constantes
Los tipos también se pueden parametrizar con valores constantes:
#[derive(Debug)]
struct Matrix<const R: usize, const C: usize> {
cells: [[f64; C]; R],
}
impl<const R: usize, const C: usize> Matrix<R, C> {
fn zero() -> Self {
Matrix { cells: [[0.0; C]; R] }
}
fn transpose(&self) -> Matrix<C, R> {
let mut out = Matrix::<C, R>::zero();
for r in 0..R {
for c in 0..C {
out.cells[c][r] = self.cells[r][c];
}
}
out
}
}
fn main() {
let mut m = Matrix::<2, 3>::zero();
m.cells[0][2] = 7.0;
let t = m.transpose(); // el tipo es Matrix<3, 2>
println!("{:?}", t.cells);
}
Las dimensiones se comprueban en tiempo de compilación y no cuestan nada en tiempo de ejecución. Los propios arrays, [T; N], son el ejemplo incorporado en el lenguaje.
Ejercicios
- Escribe un
struct Pair<T>genérico con un métodofn largest(&self) -> &Tdisponible solo cuandoT: PartialOrd. - Escribe
fn swap_pair<A, B>(p: (A, B)) -> (B, A). - Escribe un envoltorio
Stack<T>sobreVec<T>conpush,pop -> Option<T>,peek -> Option<&T>eis_empty.
Solución del 1
struct Pair<T> { a: T, b: T }
impl<T: PartialOrd> Pair<T> {
fn largest(&self) -> &T {
if self.a > self.b { &self.a } else { &self.b }
}
}
fn main() {
let p = Pair { a: "apple", b: "pear" };
println!("{}", p.largest());
}
Devolver &T evita necesitar Copy o Clone.
Comprueba lo que has entendido
Elige una respuesta para ver la explicación.
1.¿Qué es la monomorfización?
2.¿Por qué no compila
fn largest<T>(xs: &[T]) -> &Tsi el cuerpo usa>?3.¿Qué es
Nenstruct Buf<const N: usize>?