Debug y Display: imprimir para el programador y para el usuario

Defines un struct, intentas imprimirlo con {} y el compilador te frena. Pruebas con {:?} y te pide derivar algo. No es un capricho: Rust tiene dos traits de impresión, y cada uno sirve a un lector distinto. Debug es el volcado que lees tú mientras depuras; Display es la cara que tu tipo enseña al usuario final. Uno se genera mecánicamente; el otro lo escribes tú. Entender por qué son dos y no uno es entender cómo Rust separa la forma del significado.

Un valor, dos lectores

Todo valor de tu programa lo leen dos públicos con necesidades opuestas. El programador quiere ver la estructura interna para depurar: qué campos hay y qué contienen, sin adornos. El usuario final quiere una representación pensada para él, donde los detalles internos sobran y solo importa el significado. Rust se niega a servir a ambos con la misma función, y por eso reparte el trabajo en dos traits: Debug para el primero, Display para el segundo.

La marca de formato elige el trait. {:?} (y su hermana {:#?}) invoca a Debug; {} invoca a Display. No son intercambiables: un tipo puede implementar uno, el otro, ambos o ninguno, y la marca que uses exige exactamente el trait correspondiente.

Debug: el volcado del programador

Debug es para ti. Su formato reproduce la estructura del valor campo a campo, y casi nunca querrás escribirlo a mano: lo derivas.

#[derive(Debug)]
struct Usuario {
    nombre: String,
    edad: u8,
    activo: bool,
}

fn main() {
    let u = Usuario { nombre: String::from("Ada"), edad: 36, activo: true };
    println!("{u:?}");   // Usuario { nombre: "Ada", edad: 36, activo: true }
    println!("{u:#?}");  // el mismo volcado, desplegado en varias lineas
}

{:?} es compacto; {:#?} (pretty) lo despliega indentado, ideal para structs anidados. La regla práctica es simple: casi cualquier tipo debería derivar Debug. Es tan barato como añadirlo a la lista del derive, y sin él ni siquiera puedes usar assert_eq! o inspeccionar un valor en un test fallido.

Hay un matiz que se olvida: el formato de Debug no es un contrato estable. La biblioteca estándar se reserva el derecho de cambiar cómo se ven sus tipos entre versiones. No parsees la salida de {:?}; es para leerla un humano depurando, no para que la consuma otro programa.

use std::fmt;

struct Credencial {
    usuario: String,
    token: String,
}

impl fmt::Debug for Credencial {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Credencial")
            .field("usuario", &self.usuario)
            .field("token", &"[REDACTADO]")
            .finish()
    }
}

Display: la voz del tipo

Display es para el usuario. No se deriva: lo implementas tú porque solo tú sabes cómo debe presentarse tu tipo.

use std::fmt;

struct Dinero {
    centavos: i64,
}

impl fmt::Display for Dinero {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let signo = if self.centavos < 0 { "-" } else { "" };
        let abs = self.centavos.abs();
        write!(f, "{signo}{}.{:02} EUR", abs / 100, abs % 100)
    }
}

fn main() {
    let precio = Dinero { centavos: 1299 };
    println!("{precio}");                    // 12.99 EUR
    let etiqueta: String = precio.to_string(); // ToString gratis
}

El método fmt recibe un Formatter, un búfer al que empujas texto con write!, y devuelve fmt::Result. Fíjate en el regalo: implementar Display te da ToString gratis. El método .to_string() existe para todo tipo Display mediante una implementación general (impl<T: Display> ToString for T), y {} es la marca que usan println!, format! y compañía para producir la cadena orientada al usuario.

Por qué Display no se deriva

Aquí está el corazón del nivel. Debug se puede derivar porque “muestra la estructura” tiene una respuesta obvia y mecánica: escribe el nombre del tipo y lista sus campos con sus nombres. Un algoritmo lo resuelve sin ambigüedad, y eso es justo lo que hace la macro del derive.

Display no se puede derivar porque “muéstraselo a un humano” no tiene respuesta mecánica. ¿Un Dinero { centavos: 1299 } se enseña como 12.99 EUR, como $12.99, como 1299 centavos o redondeado a 13 EUR? No existe un algoritmo que lo decida: es una decisión de producto, de idioma, de contexto. Solo el autor del tipo la conoce, así que el lenguaje se la exige a él.

flowchart TD
V[Un valor] --> M[Que marca de formato usas]
M -->|interrogacion| D[Invoca Debug]
M -->|llaves vacias| P[Invoca Display]
D --> DF[Estructura mecanica derivable para el programador]
P --> PF[Significado escrito a mano para el usuario]
style D fill:#f38ba8,color:#11111b
style P fill:#a6e3a1,color:#11111b
style DF fill:#89b4fa,color:#11111b
style PF fill:#cba6f7,color:#11111b