A Trait Display

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

Enquanto o Debug é ótimo para desenvolvedores que inspecionam dados, a trait Display é projetada para saída voltada para o usuário. É o que alimenta o formatador {} no println!. Diferente do Debug, o Rust não consegue derivar automaticamente o Display—você deve implementá-lo manualmente.

Para implementar Display, você precisa importar o módulo fmt e implementar o método fmt:

use std::fmt;

struct Temperature {
    celsius: f64,
}

impl fmt::Display for Temperature {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}°C", self.celsius)
    }
}

O método fmt recebe um Formatter e retorna um fmt::Result. Você usa a macro write! para formatar sua saída, acessando os campos da struct através de self.

Agora você pode imprimir a struct com o formatador padrão {}:

let temp = Temperature { celsius: 23.5 };
println!("{}", temp);  // 23.5°C

A principal diferença: a saída Debug mostra a estrutura dos seus dados (útil para depuração), enquanto a saída Display é polida e destinada aos usuários finais. Uma struct pode implementar ambos — use {:?} para depuração e {} para uma saída limpa.

Desafio

Fácil

Vamos criar um sistema de exibição de produtos amigável ao usuário! Enquanto o Debug mostra a estrutura bruta dos seus dados, a trait Display permite que você crie uma saída polida e legível, perfeita para os usuários finais.

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

product.rs: Defina uma struct pública Product com dois campos públicos: name (String) e price (f64). Implemente a trait Display para sua struct para que ela seja formatada como {name} - ${price}. Lembre-se de importar std::fmt e usar a macro write! dentro do seu método fmt.
main.rs: Importe seu módulo de produto e crie uma instância de Product usando as entradas fornecidas. Imprima o produto usando o formatador padrão {} para mostrar sua saída de exibição personalizada.

A trait Display exige que você implemente o método fmt manualmente — o Rust não pode derivá-lo automaticamente como o Debug. Isso lhe dá controle total sobre como seu tipo aparece para os usuários.

Sua saída deve exibir o produto em um formato limpo e amigável:

{name} - ${price}

Por exemplo, com as entradas Wireless Mouse e 29.99:

Wireless Mouse - $29.99

Você receberá duas entradas: o nome do produto e o preço (analise como f64).

Folha de consulta

A trait Display é projetada para saída voltada ao usuário e alimenta o formatador {} no println!. Diferente de Debug, ela deve ser implementada manualmente.

Para implementar Display, importe o módulo fmt e implemente o método fmt:

use std::fmt;

struct Temperature {
    celsius: f64,
}

impl fmt::Display for Temperature {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}°C", self.celsius)
    }
}

O método fmt recebe um Formatter e retorna um fmt::Result. Use a macro write! para formatar a saída, acessando os campos da struct através de self.

Imprima a struct com o formatador {}:

let temp = Temperature { celsius: 23.5 };
println!("{}", temp);  // 23.5°C

Diferença chave: Debug ({:?}) mostra a estrutura de dados para depuração, enquanto Display ({}) fornece uma saída polida para os usuários finais.

Experimente você mesmo

mod product;

use product::Product;

fn main() {
    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 price_input = String::new();
    std::io::stdin().read_line(&mut price_input).expect("Failed to read line");
    let price: f64 = price_input.trim().parse().expect("Failed to parse price");

    // TODO: Criar uma instância de Product com o name e price

    // TODO: Imprimir o produto usando o formatador {}
}