El trait Debug

Parte de la sección Programación Orientada a Objetos del Journey de Rust de Coddy. Lección 35 de 61.

La biblioteca estándar de Rust incluye muchos traits predefinidos que proporcionan funcionalidad común. Uno de los más útiles para el desarrollo es el trait Debug, que te permite imprimir el contenido de una estructura para inspeccionarlo.

Si intentas imprimir una estructura personalizada directamente, Rust no sabrá cómo mostrarla:

struct Player {
    name: String,
    score: u32,
}

let p = Player { name: String::from("Alice"), score: 100 };
println!("{:?}", p);  // ¡Error! Debug no implementado

El formateador {:?} requiere el trait Debug. En lugar de implementarlo manualmente, Rust proporciona un atajo: el atributo #[derive]. Colócalo directamente encima de la definición de tu estructura:

#[derive(Debug)]
struct Player {
    name: String,
    score: u32,
}

let p = Player { name: String::from("Alice"), score: 100 };
println!("{:?}", p);  // Player { name: "Alice", score: 100 }

El atributo #[derive(Debug)] indica al compilador que genere automáticamente la implementación de Debug. Esto funciona siempre que todos los campos de tu struct también implementen Debug (lo que hacen la mayoría de los tipos estándar).

Para obtener una salida más legible con estructuras anidadas, usa {:#?} para imprimir con formato bonito:

println!("{:#?}", p);
// Player {
//     name: "Alice",
//     score: 100,
// }

Derivar Debug es esencial durante el desarrollo. Te permite inspeccionar rápidamente tus datos sin escribir código de formato personalizado.

Desafío

Fácil

¡Hagamos que tus estructuras se puedan inspeccionar derivando el rasgo Debug! Crearás un sistema de inventario sencillo en el que los artículos se puedan imprimir con fines de depuración.

Organizarás tu código en dos archivos:

inventory.rs: Define una estructura Item pública con dos campos públicos: name (String) y quantity (u32). Usa el atributo #[derive(Debug)] para implementar automáticamente el rasgo Debug en tu estructura.
main.rs: Incluye tu módulo de inventario y crea una instancia de Item usando las entradas proporcionadas. Imprime el artículo con el formateador de depuración {:?} para mostrar su estructura interna.

La ventaja de derivar Debug es que Rust genera automáticamente el código de formato por ti: ¡no hace falta ninguna implementación manual! Tu estructura solo necesita el atributo y se vuelve imprimible con {:?}.

Tu salida debe mostrar el artículo en el formato de depuración de Rust:

Item { name: "{name}", quantity: {quantity} }

Por ejemplo, con las entradas Keyboard y 15:

Item { name: "Keyboard", quantity: 15 }

Recibirás dos entradas: el nombre del artículo y la cantidad (analízala como u32).

Pruébalo tú mismo

mod inventory;

use inventory::Item;

fn main() {
    // Lee la entrada
    let mut name = String::new();
    std::io::stdin().read_line(&mut name).expect("Failed to read line");
    let name = name.trim().to_string();
    
    let mut quantity_str = String::new();
    std::io::stdin().read_line(&mut quantity_str).expect("Failed to read line");
    let quantity: u32 = quantity_str.trim().parse().expect("Failed to parse quantity");
    
    // TODO: Crea una instancia de Item con el name y quantity dados
    
    // TODO: Imprime el item usando el formateador de depuración {:?}
}