Il trait Display

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

Se Debug è ottimo per gli sviluppatori che ispezionano i dati, il trait Display è progettato per l'output rivolto agli utenti. È ciò che alimenta il formattatore {} in println!. A differenza di Debug, Rust non può derivare automaticamente Display. Devi implementarlo manualmente.

Per implementare Display, devi importare il modulo fmt e implementare il metodo 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)
    }
}

Il metodo fmt riceve un Formatter e restituisce un fmt::Result. Usa la macro write! per formattare il tuo output, accedendo ai campi della struct tramite self.

Ora puoi stampare la struct con il formatter standard {}:

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

La differenza fondamentale: l'output di Debug mostra la struttura dei tuoi dati (utile per il debug), mentre l'output di Display è rifinito ed è pensato per gli utenti finali. Una struct può implementare entrambi: usa {:?} per il debug e {} per un output pulito.

Sfida

Facile

Creiamo un sistema intuitivo per visualizzare i prodotti! Mentre Debug mostra la struttura grezza dei tuoi dati, il trait Display ti permette di creare un output curato e leggibile, perfetto per gli utenti finali.

Organizzerai il codice in due file:

product.rs: definisci una struct pubblica Product con due campi pubblici: name (String) e price (f64). Implementa il trait Display per la tua struct, in modo che venga formattata come {name} - ${price}. Ricordati di importare std::fmt e di usare la macro write! all'interno del metodo fmt.
main.rs: importa il modulo del prodotto e crea un'istanza di Product usando gli input forniti. Stampa il prodotto usando il formattatore standard {} per mostrare il tuo output personalizzato.

Il trait Display richiede di implementare manualmente il metodo fmt: Rust non può derivarlo automaticamente come fa con Debug. Questo ti dà il pieno controllo su come il tuo tipo viene mostrato agli utenti.

L'output dovrebbe mostrare il prodotto in un formato chiaro e intuitivo:

{name} - ${price}

Per esempio, con gli input Wireless Mouse e 29.99:

Wireless Mouse - $29.99

Riceverai due input: il nome del prodotto e il prezzo (da analizzare come f64).

Provalo tu

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: Crea un'istanza di Product con il nome e il prezzo

    // TODO: Stampa il prodotto usando il formattatore {}
}