El trait Display

Parte de la sección Object Oriented Programming del Journey de Rust de Coddy — lección 36 de 61.

Mientras que Debug es ideal para desarrolladores que inspeccionan datos, el trait Display está diseñado para salida orientada al usuario. Es lo que potencia el formateador {} en println!. A diferencia de Debug, Rust no puede derivar automáticamente Display—debes implementarlo manualmente.

Para implementar Display, necesitas importar el módulo fmt e implementar el 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)
    }
}

El método fmt recibe un Formatter y devuelve un fmt::Result. Usa la macro write! para formatear tu salida, accediendo a los campos de la estructura a través de self.

Ahora puedes imprimir la estructura con el formateador estándar {}:

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

La diferencia clave: la salida Debug muestra la estructura de tus datos (útil para la depuración), mientras que la salida Display está pulida y pensada para los usuarios finales. Una estructura puede implementar ambas; usa {:?} para la depuración y {} para una salida limpia.

Desafío

Fácil

¡Vamos a crear un sistema de visualización de productos fácil de usar! Mientras que Debug muestra la estructura bruta de tus datos, el trait Display te permite crear una salida pulida y legible para humanos, perfecta para los usuarios finales.

Organizarás tu código en dos archivos:

product.rs: Define una estructura Product pública con dos campos públicos: name (String) y price (f64). Implementa el trait Display para tu estructura de modo que se formatee como {name} - ${price}. Recuerda importar std::fmt y usar la macro write! dentro de tu método fmt.
main.rs: Importa tu módulo product y crea una instancia de Product utilizando las entradas proporcionadas. Imprime el producto usando el formateador estándar {} para mostrar tu salida de visualización personalizada.

El trait Display requiere que implementes el método fmt manualmente; Rust no puede derivarlo automáticamente como Debug. Esto te da un control total sobre cómo aparece tu tipo ante los usuarios.

Tu salida debe mostrar el producto en un formato limpio y fácil de usar:

{name} - ${price}

Por ejemplo, con las entradas Wireless Mouse y 29.99:

Wireless Mouse - $29.99

Recibirás dos entradas: el nombre del producto y el precio (analizado como f64).

Hoja de referencia

El trait Display está diseñado para salida orientada al usuario y potencia el formateador {} en println!. A diferencia de Debug, debe implementarse manualmente.

Para implementar Display, importa el módulo fmt e implementa el 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)
    }
}

El método fmt recibe un Formatter y devuelve un fmt::Result. Usa la macro write! para formatear la salida, accediendo a los campos de la estructura a través de self.

Imprime la estructura con el formateador {}:

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

Diferencia clave: Debug ({:?}) muestra la estructura de datos para la depuración, mientras que Display ({}) proporciona una salida pulida para los usuarios finales.

Pruébalo tú mismo

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: Crear una instancia de Product con el nombre y el precio

    // TODO: Imprimir el producto usando el formateador {}
}