FerrousPath

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

  1. Escribe un struct Pair<T> genérico con un método fn largest(&self) -> &T disponible solo cuando T: PartialOrd.
  2. Escribe fn swap_pair<A, B>(p: (A, B)) -> (B, A).
  3. Escribe un envoltorio Stack<T> sobre Vec<T> con push, pop -> Option<T>, peek -> Option<&T> e is_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. 1.¿Qué es la monomorfización?

  2. 2.¿Por qué no compila fn largest<T>(xs: &[T]) -> &T si el cuerpo usa >?

  3. 3.¿Qué es N en struct Buf<const N: usize>?

Términos clave de esta lección

¿Has terminado la lección y los ejercicios?