Nivel 4 · Experto· Lección 8 de 9 · 35 min
Programación a nivel de tipos
Typestate, tipos fantasma, genéricos constantes, cálculo a nivel de tipos con traits, y cómo hacer que los programas inválidos no compilen.
El sistema de tipos de Rust puede comprobar mucho más que «esto es un entero». Con parámetros fantasma, traits y genéricos constantes puedes trasladar clases enteras de errores de ejecución —llamadas en un orden incorrecto, unidades que no cuadran, búferes de tamaño equivocado— al tiempo de compilación, sin ningún coste en tiempo de ejecución.
Typestate
Un protocolo tiene estados, y cada estado permite operaciones distintas. Codifica el estado como un parámetro de tipo:
use std::marker::PhantomData;
// Estados: tipos marcadores de tamaño cero.
struct Disconnected;
struct Connected;
struct Authenticated;
struct Session<State> {
host: String,
log: Vec<String>,
_state: PhantomData<State>,
}
impl Session<Disconnected> {
fn new(host: &str) -> Self {
Session { host: host.into(), log: vec![], _state: PhantomData }
}
fn connect(mut self) -> Session<Connected> {
self.log.push(format!("connected to {}", self.host));
self.transition()
}
}
impl Session<Connected> {
fn login(mut self, user: &str, password: &str) -> Result<Session<Authenticated>, Session<Connected>> {
if password == "hunter2" {
self.log.push(format!("{user} logged in"));
Ok(self.transition())
} else {
self.log.push("bad password".into());
Err(self) // sigue en el estado Connected; quien llama puede reintentar
}
}
}
impl Session<Authenticated> {
fn query(&mut self, sql: &str) -> usize {
self.log.push(format!("ran `{sql}`"));
sql.len()
}
}
// Disponible en todos los estados.
impl<S> Session<S> {
fn transition<T>(self) -> Session<T> {
Session { host: self.host, log: self.log, _state: PhantomData }
}
fn log(&self) -> &[String] {
&self.log
}
}
fn main() {
let session = Session::new("db.example.com").connect();
// session.query("SELECT 1"); // ❌ no compilaría: no existe el método `query` en Session<Connected>
let session = match session.login("ada", "wrong") {
Ok(s) => s,
Err(s) => s.login("ada", "hunter2").ok().expect("second attempt"),
};
let mut session = session;
session.query("SELECT 1");
println!("{:#?}", session.log());
}
Las transiciones reciben self por valor, así que el estado antiguo se consume: no puedes seguir usando un Session<Connected> después de iniciar sesión. La propiedad y el typestate se refuerzan mutuamente: en un lenguaje sin semántica de movimiento, el manejador obsoleto seguiría siendo utilizable.
Cuándo usarlo: en protocolos con un conjunto pequeño y lineal de estados en los que usarlos mal sale caro (builders con campos obligatorios, negociaciones de conexión, pines de hardware, ciclos de vida de transacciones). Cuando los estados son numerosos o se eligen en tiempo de ejecución, un enum es la mejor herramienta.
Tipos fantasma para unidades y marcas
use std::marker::PhantomData;
use std::ops::{Add, Div};
#[derive(Debug, Clone, Copy, PartialEq)]
struct Quantity<Unit> {
value: f64,
_unit: PhantomData<Unit>,
}
#[derive(Debug, Clone, Copy, PartialEq)] struct Metres;
#[derive(Debug, Clone, Copy, PartialEq)] struct Seconds;
#[derive(Debug, Clone, Copy, PartialEq)] struct MetresPerSecond;
impl<U> Quantity<U> {
const fn new(value: f64) -> Self {
Quantity { value, _unit: PhantomData }
}
}
// Las mismas unidades se suman.
impl<U> Add for Quantity<U> {
type Output = Quantity<U>;
fn add(self, o: Self) -> Self { Quantity::new(self.value + o.value) }
}
// Distancia / tiempo = velocidad. No hay definida ninguna otra división.
impl Div<Quantity<Seconds>> for Quantity<Metres> {
type Output = Quantity<MetresPerSecond>;
fn div(self, t: Quantity<Seconds>) -> Self::Output { Quantity::new(self.value / t.value) }
}
fn main() {
let d = Quantity::<Metres>::new(100.0) + Quantity::new(100.0);
let t = Quantity::<Seconds>::new(19.19);
let v: Quantity<MetresPerSecond> = d / t;
println!("{:.2} m/s", v.value);
// let nonsense = d + t; // ❌ no compilaría: los tipos no coinciden
// let also = t / d; // ❌ no compilaría: no hay ningún impl de Div
}
Quantity<Metres> y Quantity<Seconds> son los dos un simple f64 en tiempo de ejecución. El Mars Climate Orbiter se perdió por un error de unidades que esto convierte en un error de compilación. El crate uom desarrolla la idea por completo.
Los genéricos constantes como valores a nivel de tipos
#[derive(Debug, Clone, Copy)]
struct Matrix<const R: usize, const C: usize>([[i64; C]; R]);
impl<const R: usize, const C: usize> Matrix<R, C> {
// Las dimensiones interiores deben coincidir: lo comprueba el sistema de tipos.
fn mul<const K: usize>(&self, rhs: &Matrix<C, K>) -> Matrix<R, K> {
let mut out = [[0; K]; R];
for r in 0..R {
for k in 0..K {
for c in 0..C {
out[r][k] += self.0[r][c] * rhs.0[c][k];
}
}
}
Matrix(out)
}
}
/// Un búfer cuya capacidad debe ser una potencia de dos: se verifica en tiempo de compilación.
struct Ring<const N: usize> {
data: [u8; N],
head: usize,
}
impl<const N: usize> Ring<N> {
const CHECK: () = assert!(N.is_power_of_two(), "Ring capacity must be a power of two");
fn new() -> Self {
let () = Self::CHECK; // fuerza la evaluación para este N
Ring { data: [0; N], head: 0 }
}
fn push(&mut self, byte: u8) {
self.data[self.head & (N - 1)] = byte; // vuelta barata, válida solo para potencias de dos
self.head += 1;
}
}
fn main() {
let a = Matrix([[1, 2, 3], [4, 5, 6]]); // 2×3
let b = Matrix([[1, 0], [0, 1], [1, 1]]); // 3×2
println!("{:?}", a.mul(&b)); // 2×2
// a.mul(&a); // ❌ no compilaría: se esperaba Matrix<3, _>, se encontró Matrix<2, 3>
let mut ring = Ring::<8>::new();
for b in 0..10 { ring.push(b); }
println!("{:?}", ring.data);
// Ring::<6>::new(); // ❌ no compila: "Ring capacity must be a power of two"
}
Una const asociada que contiene un assert! es una comprobación posterior a la monomorfización: se evalúa por cada instancia, lo que convierte una propiedad de un parámetro constante en un error de compilación. Los genéricos constantes estables aceptan enteros, bool y char; la aritmética en los tipos ([T; N + 1]) sigue siendo inestable (generic_const_exprs).
Calcular con traits
Un impl de un trait es una regla lógica; el resolutor que busca un impl está buscando una demostración. Con los tipos asociados, la búsqueda devuelve una respuesta. Aritmética de Peano, enteramente en tiempo de compilación:
use std::marker::PhantomData;
struct Zero;
struct Succ<N>(PhantomData<N>);
trait Nat { const VALUE: usize; }
impl Nat for Zero { const VALUE: usize = 0; }
impl<N: Nat> Nat for Succ<N> { const VALUE: usize = N::VALUE + 1; }
// Suma: 0 + B = B S(A) + B = S(A + B)
trait Add<B> { type Sum; }
impl<B> Add<B> for Zero { type Sum = B; }
impl<A: Add<B>, B> Add<B> for Succ<A> { type Sum = Succ<A::Sum>; }
type One = Succ<Zero>;
type Two = Succ<One>;
type Three = Succ<Two>;
type Five = <Two as Add<Three>>::Sum;
/// Un vector cuya longitud se sigue en su tipo.
struct Vect<T, N> { items: Vec<T>, _len: PhantomData<N> }
impl<T> Vect<T, Zero> {
fn new() -> Self { Vect { items: Vec::new(), _len: PhantomData } }
}
impl<T, N> Vect<T, N> {
fn push(mut self, item: T) -> Vect<T, Succ<N>> {
self.items.push(item);
Vect { items: self.items, _len: PhantomData }
}
}
impl<T, N> Vect<T, Succ<N>> {
/// `first` solo existe para vectores no vacíos, así que no necesita Option.
fn first(&self) -> &T { &self.items[0] }
}
fn main() {
println!("2 + 3 = {}", <Five as Nat>::VALUE);
let v = Vect::new().push("a").push("b");
println!("{}", v.first());
// Vect::<u8, Zero>::new().first(); // ❌ no compilaría: no existe el método `first` en Vect<u8, Zero>
}
El crate typenum es esta idea llevada a la práctica (en binario en lugar de en unario), y fue lo que hizo posibles los arrays de tamaño fijo en el ecosistema antes de los genéricos constantes. La misma maquinaria implementa listas heterogéneas (frunk), análisis dimensional en tiempo de compilación y máquinas de estados a nivel de tipos.
El sistema de traits es Turing-completo, y por eso el compilador tiene un límite de recursión. Eso es tanto una advertencia como un alarde.
Otras técnicas, brevemente
- Traits sellados y traits marcadores para definir conjuntos cerrados de tipos (
trait State: sealed::Sealed), de modo que los usuarios no puedan inventarse un estado. - Tipos testigo y tokens: un valor cuya existencia demuestra que algo ocurrió. Un
MutexGuarddemuestra que se tiene el cerrojo; un tokenInitializedde tamaño cero, devuelto porinit()y exigido por otras funciones, demuestra el orden. - Lifetimes marcados: un lifetime invariante creado por una clausura
for<'id>es único, así que de los índices marcados con él se puede demostrar que están dentro de los límites de una colección concreta (GhostCell, el crateindexing). - Patrones de tipos de orden superior mediante GAT: abstraer sobre
Option<_>oVec<_>como constructores de tipos. const fny evaluación constante: calcular tablas de consulta y validar la configuración en tiempo de compilación.
Criterio
La programación a nivel de tipos es un intercambio. Compra garantías; cuesta calidad en los mensajes de error, tiempo de compilación y número de personas capaces de mantener el código. Pautas:
- Codifica los invariantes cuya violación sea cara y plausible. Un newtype es casi gratis. Un builder con typestate es barato. Un intérprete a nivel de tipos rara vez merece la pena.
- Prefiere el mecanismo más simple: newtype → enum → typestate → genéricos constantes → cálculo a nivel de traits.
- Comprueba lo que ven los usuarios cuando se equivocan.
#[diagnostic::on_unimplemented]te permite dar un mensaje legible cuando falta un impl.
Ejercicios
- Escribe un builder con typestate para
HttpRequesten el queurlymethodsean obligatorios ybuild()solo exista cuando los dos se hayan asignado. Usa dos parámetros de tipo con marcadoresMissing/Present. - Amplía
QuantityconMulpara queMetresPerSecond × Seconds = Metres. - Añade la multiplicación a nivel de tipos a los números de Peano y comprueba que
2 × 3 = 6. - Escribe
fn concat<T, const A: usize, const B: usize>(a: [T; A], b: [T; B]) -> Vec<T>y explica por qué no es posible devolver[T; A + B]en Rust estable. - Implementa un manejador de archivo con los estados
Closed,Open<ReadOnly>yOpen<ReadWrite>, en el quewritesolo exista paraReadWrite.
Comprueba lo que has entendido
Elige una respuesta para ver la explicación.
1.¿Qué es el patrón typestate?
2.¿Qué coste en tiempo de ejecución añade un marcador
PhantomData<State>?3.¿Por qué el sistema de traits de Rust equivale a un lenguaje de programación lógica?