El trait Display

Parte de la sección Programación Orientada a Objetos del Journey de Rust de Coddy. Lección 36 de 61.

Mientras que Debug es excelente para que los desarrolladores inspeccionen datos, el trait Display está diseñado para la salida destinada al usuario. Es lo que hace funcionar el formateador {} en println!. A diferencia de Debug, Rust no puede derivar automáticamente Display. Debes implementarlo manualmente.

Para implementar Display, necesitas incluir 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. Usas la macro write! para dar formato a tu salida, accediendo a los campos de la estructura mediante 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 de Debug muestra la estructura de tus datos (útil para depurar), mientras que la salida de Display está pulida y destinada a los usuarios finales. Una estructura puede implementar ambos: usa {:?} para depurar y {} para obtener una salida limpia.

Desafío

Fácil

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

Organizarás tu código en dos archivos:

product.rs: Define una estructura pública Product 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 de productos y crea una instancia de Product usando 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 manualmente el método fmt: Rust no puede derivarlo automáticamente como Debug. Esto te da control total sobre cómo aparece tu tipo para 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 (analízalo como f64).

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: Crea una instancia de Product con el name y el price

    // TODO: Imprime el product usando el formateador {}
}