Rust par l'exemple

// Cette structure ne peut être affichée par `fmt::Debug`, 
// ni par `fmt::Display`.
struct UnPrintable(i32);

// L'attribut `derive` créé automatiquement l'implémentation requise 
// pour permettre à cette structure d'être affichée avec `fmt::Debug`.
#[derive(Debug)]
struct DebugPrintable(i32);

// On fait hériter l'implémentation de `fmt::Debug` pour `Structure`.
// `Structure` est une structure qui contient un simple entier de type `i32`.
#[derive(Debug)]
struct Structure(i32);

// On créé une structure nommée `Deep`, que l'on rend également affichable,
// contenant un champ de type `Structure`,
#[derive(Debug)]
struct Deep(Structure);

fn main() {
    // L'affichage avec le marqueur `{:?}` est similaire à `{}`,
    // pour des types standards comme les entiers et les chaînes de caractères.
    println!("{:?} mois dans une année.", 12);
    println!("{1:?} {0:?} est le nom de {actor:?}.",
             "Slater",
             "Christian",
             actor="l'acteur");

    // `Structure` peut être affichée !
    println!("{:?} peut désormais être affichée!", Structure(3));

    // Le problème avec `derive` est que vous n'avez aucun contrôle quant au résultat
    // affiché. Comment faire si je souhaite seulement afficher `7` ?
    println!("{:?} peut désormais être affichée!", Deep(Structure(7)));
}

// On importe (via `use`) le module `fmt` pour le rendre accessible.
use std::fmt;

// Nous définissons une structure dans laquelle le trait `fmt::Display` 
// sera implémenté. Ce n'est qu'un simple tuple, nommée `Structure`, contenant un entier de type i32. 
struct Structure(i32);

// Pour pouvoir utiliser le marqueur `{}`, le trait `fmt::Display` doit être implémenté 
// manuellement pour le type.
impl fmt::Display for Structure {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        // écrit le premier élément de la structure dans le flux en sortie
        // soumis: `f`. Renvoie une instance de `fmt::Result` qui témoigne du succès 
        // ou de l'échec de l'opération. Notez que `write!` possède une syntaxe très 
        // similaire à `println!`.
        write!(f, "{}", self.0)
    }
}

use std::fmt; // On importe le module `fmt`

// Une structure qui contient deux nombres. `Debug` va être hérité pour que les résultats
// puissent être comparés avec `Display`.
#[derive(Debug)]
struct MinMax(i64, i64);

// Implémentation du trait `Display` pour la structure `MinMax`.
impl fmt::Display for MinMax {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        // On utilise `self.nombre` pour faire référence à la donnée se trouvant
        // à cette position.
        write!(f, "({}, {})", self.0, self.1)
    }
}

// Définissons une structure où les champs sont nommés pour comparer.
#[derive(Debug)]
struct Point2D {
    x: f64,
    y: f64,
}

// On implémente également le trait fmt::Display pour la structure Point2D
impl fmt::Display for Point2D {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        // On désigne les champs de notre choix. (en l'occurrence `x` et `y`)
        write!(f, "x: {}, y: {}", self.x, self.y)
    }
}

fn main() {
    let minmax = MinMax(0, 14);

    println!("Comparaison des structures:");
    println!("Display: {}", minmax);
    println!("Debug: {:?}", minmax);

    let big_range =   MinMax(-300, 300);
    let small_range = MinMax(-3, 3);

    println!("Le grand intervalle est {big} et le petit est {small}",
             small = small_range,
             big = big_range);

    let point = Point2D { x: 3.3, y: 7.2 };

    println!("Comparaison des points:");
    println!("Display: {}", point);
    println!("Debug: {:?}", point);
    
    // Erreur. Les traits `Debug` and `Display` étaient implémentés mais 
    // le marqueur `{:b}` requiert l'implémentation du trait `fmt::Binary`.
    // Cela ne fonctionnera pas.
    // println!("A quoi ressemble Point2D formaté en binaire: {:b} ?", point);
}

use std::fmt::{self, Formatter, Display};

struct City {
    name: &'static str,
    // Latitude
    lat: f32,
    // Longitude
    lon: f32,
}

impl Display for City {
    // `f` est un tampon, cette méthode écrit la chaîne de caractères
    // formattée à l'intérieur de ce dernier.
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        let lat_c = if self.lat >= 0.0 { 'N' } else { 'S' };
        let lon_c = if self.lon >= 0.0 { 'E' } else { 'W' };

        // `write!` est équivalente à `format!`, à l'exception qu'elle écrira
        // la chaîne de caractères formatée dans un tampon (le premier argument).
        write!(f, "{}: {:.3}°{} {:.3}°{}",
               self.name, self.lat.abs(), lat_c, self.lon.abs(), lon_c)
    }
}

#[derive(Debug)]
struct Color {
    red: u8,
    green: u8,
    blue: u8,
}

fn main() {
    for city in [
        City { name: "Dublin", lat: 53.347778, lon: -6.259722 },
        City { name: "Oslo", lat: 59.95, lon: 10.75 },
        City { name: "Vancouver", lat: 49.25, lon: -123.1 },
    ].iter() {
        println!("{}", *city);
    }
    for color in [
        Color { red: 128, green: 255, blue: 90 },
        Color { red: 0, green: 3, blue: 254 },
        Color { red: 0, green: 0, blue: 0 },
    ].iter() {
        // Utilisez le marqueur `{}` une fois que vous aurez implémenté
        // le trait fmt::Display.
        println!("{:?}", *color)
    }
}