Il trait Debug

Fa parte della sezione Programmazione orientata agli oggetti del percorso Rust di Coddy. Lezione 35 di 61.

La libreria standard di Rust include molti trait predefiniti che forniscono funzionalità comuni. Uno dei più utili per lo sviluppo è il trait Debug, che ti permette di stampare il contenuto di una struct per ispezionarlo.

Se provi a stampare direttamente una struct personalizzata, Rust non saprà come visualizzarla:

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

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

Il formattatore {:?} richiede il trait Debug. Invece di implementarlo manualmente, Rust offre una scorciatoia: l'attributo #[derive]. Inseriscilo direttamente sopra la definizione della struct:

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

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

L'attributo #[derive(Debug)] dice al compilatore di generare automaticamente l'implementazione di Debug. Funziona purché tutti i campi della tua struct implementino anche Debug (come avviene per la maggior parte dei tipi standard).

Per ottenere un output più leggibile con strutture annidate, usa {:#?} per la formattazione elegante:

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

Derivare Debug è essenziale durante lo sviluppo. Ti permette di esaminare rapidamente i tuoi dati senza scrivere codice di formattazione personalizzato.

Sfida

Facile

Rendiamo ispezionabili le tue struct derivando il trait Debug! Creerai un semplice sistema di inventario in cui gli articoli possono essere stampati a scopo di debug.

Organizzerai il codice in due file:

inventory.rs: Definisci una struct pubblica Item con due campi pubblici: name (String) e quantity (u32). Usa l’attributo #[derive(Debug)] per implementare automaticamente il trait Debug per la tua struct.
main.rs: Includi il modulo inventory e crea un’istanza di Item usando gli input forniti. Stampa l’articolo usando il formattatore di debug {:?} per visualizzarne la struttura interna.

Il bello di derivare Debug è che Rust genera automaticamente il codice di formattazione per te: non serve alcuna implementazione manuale! Alla tua struct basta l’attributo per poter essere stampata con {:?}.

Il tuo output dovrebbe mostrare l’articolo nel formato di debug di Rust:

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

Ad esempio, con gli input Keyboard e 15:

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

Riceverai due input: il nome dell’articolo e la quantità (da analizzare come u32).

Provalo tu

mod inventory;

use inventory::Item;

fn main() {
    // Leggi l'input
    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 un'istanza di Item con il nome e la quantità forniti
    
    // TODO: Stampa l'elemento usando il formattatore di debug {:?}
}