A Trait Debug

Parte da seção Object Oriented Programming do Journey de Rust da Coddy — lição 35 de 61.

A biblioteca padrão do Rust vem com muitos traits pré-definidos que fornecem funcionalidades comuns. Um dos mais úteis para o desenvolvimento é o trait Debug, que permite imprimir o conteúdo de uma struct para inspeção.

Se você tentar imprimir uma struct personalizada diretamente, o Rust não saberá como exibi-la:

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

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

O formatador {:?} requer a trait Debug. Em vez de implementá-la manualmente, o Rust fornece um atalho — o atributo #[derive]. Coloque-o diretamente acima da definição da sua 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 }

O atributo #[derive(Debug)] diz ao compilador para gerar automaticamente a implementação Debug. Isso funciona desde que todos os campos em sua struct também implementem Debug (o que a maioria dos tipos padrão faz).

Para uma saída mais legível com estruturas aninhadas, use {:#?} para uma formatação amigável (pretty-printing):

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

Derivar Debug é essencial durante o desenvolvimento — ele permite que você inspecione rapidamente seus dados sem escrever código de formatação personalizado.

Desafio

Fácil

Vamos tornar suas structs inspecionáveis derivando a trait Debug! Você criará um sistema de inventário simples onde os itens podem ser impressos para fins de depuração.

Você organizará seu código em dois arquivos:

inventory.rs: Defina uma struct pública Item com dois campos públicos: name (String) e quantity (u32). Use o atributo #[derive(Debug)] para implementar automaticamente a trait Debug para sua struct.
main.rs: Importe seu módulo de inventário e crie uma instância de Item usando as entradas fornecidas. Imprima o item usando o formatador de depuração {:?} para exibir sua estrutura interna.

A beleza de derivar Debug é que o Rust gera automaticamente o código de formatação para você — nenhuma implementação manual é necessária! Sua struct só precisa do atributo e ela se torna imprimível com {:?}.

Sua saída deve exibir o item no formato de depuração do Rust:

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

Por exemplo, com as entradas Keyboard e 15:

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

Você receberá duas entradas: o nome do item e a quantidade (converta para u32).

Folha de consulta

O trait Debug permite que você imprima o conteúdo de uma struct para inspeção usando o formatador {:?}.

Use o atributo #[derive(Debug)] para implementar automaticamente o Debug para sua 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 }

Para uma saída formatada (pretty-printed) com melhor formatação, use {:#?}:

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

O atributo #[derive(Debug)] funciona desde que todos os campos em sua struct também implementem Debug, o que a maioria dos tipos padrão faz.

Experimente você mesmo

mod inventory;

use inventory::Item;

fn main() {
    // Ler 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: Criar uma instância de Item com o nome e a quantidade fornecidos
    
    // TODO: Imprimir o item usando o formatador de depuração {:?}
}