Derivar traits: Debug, Clone y el formato de depuración

Imprime un struct recién definido con {} y el compilador te frena: no sabe cómo mostrarlo. La solución no es escribir código de formato a mano, sino pedirle al compilador que lo genere con #[derive(...)]. Ese pequeño atributo es tu primera ventana a los traits, el mecanismo con el que Rust abstrae capacidades.

derive: el compilador escribe el impl

Un struct nuevo no sabe imprimirse. Esto no compila:

struct Punto { x: i32, y: i32 }

let p = Punto { x: 1, y: 2 };
println!("{:?}", p);   // error: Punto no implementa Debug

En vez de escribir la implementación a mano, la derivas:

#[derive(Debug)]
struct Punto { x: i32, y: i32 }

let p = Punto { x: 1, y: 2 };
println!("{:?}", p);   // Punto { x: 1, y: 2 }

#[derive(Debug)] es un atributo que corre en compilación y genera la implementación del trait Debug por ti, campo a campo. No hay coste en tiempo de ejecución: el código generado es el que habrías escrito a mano.

Depurar con {:?} y {:#?}

Debug es para ti, el programador: un volcado estructural para inspeccionar y depurar. Tiene dos formatos:

#[derive(Debug)]
struct Config { host: String, puerto: u16, tls: bool }

let c = Config { host: String::from("localhost"), puerto: 8080, tls: true };

println!("{:?}", c);
// Config { host: "localhost", puerto: 8080, tls: true }

println!("{:#?}", c);
// Config {
//     host: "localhost",
//     puerto: 8080,
//     tls: true,
// }

{:?} es compacto; {:#?} (pretty) lo despliega en varias líneas, ideal para structs anidados. Ojo: {} (sin el ?) usa el trait Display, que no es derivable —lo veremos enseguida—.

Clone y Copy

Clone añade el método .clone(), que produce una copia profunda e independiente:

#[derive(Debug, Clone)]
struct Perfil { nombre: String, etiquetas: Vec<String> }

let a = Perfil { nombre: String::from("Ada"), etiquetas: vec![] };
let b = a.clone();      // copia explícita; 'a' sigue siendo válido

Clone es explícito a propósito: como copiar un String o un Vec reserva memoria, Rust te obliga a pedirlo con .clone() para que el coste sea visible. Su pariente Copy es para tipos triviales (enteros, bool, char) que se duplican copiando sus bits; con Copy, la asignación duplica en vez de mover, sin llamar a ningún código:

#[derive(Debug, Clone, Copy)]
struct Coord { x: i32, y: i32 }   // solo campos Copy, así que puede ser Copy

let p = Coord { x: 1, y: 2 };
let q = p;                        // COPIA implícita; 'p' sigue válido

Un tipo solo puede ser Copy si todos sus campos lo son: un struct con un String (que no es Copy) nunca podrá derivar Copy.

El zoo de traits derivables

Debug, Clone y Copy son la punta del iceberg. Los derivables estándar más frecuentes: