Traits et génériques : les interfaces de Rust

/// Tout ce qui a une valeur d'achat dans le parc.
trait Valorisable {
    /// Valeur HT en centimes : chaque type doit la fournir.
    fn valeur_ht(&self) -> u64;

    /// Valeur TTC : méthode par défaut, héritée telle quelle.
    fn valeur_ttc(&self) -> u64 {
        self.valeur_ht() * 120 / 100
    }
}

struct Poste {
    numero: String,
    prix_ht: u32,
}

struct Licence {
    logiciel: String,
    prix_annuel_ht: u32,
    nb_postes: u32,
}

impl Valorisable for Poste {
    fn valeur_ht(&self) -> u64 {
        u64::from(self.prix_ht)
    }
}

impl Valorisable for Licence {
    fn valeur_ht(&self) -> u64 {
        u64::from(self.prix_annuel_ht) * u64::from(self.nb_postes)
    }
}

interface IValorisable
{
    long ValeurHt();
    long ValeurTtc() => ValeurHt() * 120 / 100; // méthode par défaut (C# 8 et plus)
}

class Poste(string numero, int prixHt) : IValorisable
{
    public string Numero { get; } = numero;
    public long ValeurHt() => prixHt;
}

class Licence(string logiciel, int prixAnnuelHt, int nbPostes) : IValorisable
{
    public string Logiciel { get; } = logiciel;
    public long ValeurHt() => (long)prixAnnuelHt * nbPostes;
}

use std::fmt;

impl fmt::Display for Poste {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "poste {}", self.numero)
    }
}

impl fmt::Display for Licence {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "licence {} ({} postes)", self.logiciel, self.nb_postes)
    }
}

/// Générique : marche pour une tranche de n'importe quel type Valorisable.
fn total_ht<T: Valorisable>(elements: &[T]) -> u64 {
    elements.iter().map(|e| e.valeur_ht()).sum()
}

/// impl Trait : la même idée, écrite plus court, pour un seul élément.
fn afficher(element: &(impl Valorisable + fmt::Display)) {
    println!("{element} : {} HT, {} TTC", element.valeur_ht(), element.valeur_ttc());
}

fn main() {
    let postes = vec![
        Poste { numero: String::from("PC-0001"), prix_ht: 89900 },
        Poste { numero: String::from("PC-0002"), prix_ht: 64900 },
    ];
    let suite = Licence { logiciel: String::from("Suite bureautique"), prix_annuel_ht: 12600, nb_postes: 12 };

    println!("Postes : {} centimes HT", total_ht(&postes));
    afficher(&postes[0]);
    afficher(&suite);
}

Postes : 154800 centimes HT
poste PC-0001 : 89900 HT, 107880 TTC
licence Suite bureautique (12 postes) : 151200 HT, 181440 TTC

fn rapport<T>(elements: &[T]) -> String
where
    T: Valorisable + fmt::Display,
{
    elements
        .iter()
        .map(|e| format!("{e} : {} HT", e.valeur_ht()))
        .collect::<Vec<String>>()
        .join("\n")
}

static long TotalHt<T>(IEnumerable<T> elements) where T : IValorisable =>
    elements.Sum(e => e.ValeurHt());

let budget: Vec<Box<dyn Valorisable>> = vec![
    Box::new(Poste { numero: String::from("PC-0003"), prix_ht: 104900 }),
    Box::new(suite),
];
let total: u64 = budget.iter().map(|e| e.valeur_ht()).sum();
println!("Budget : {total} centimes HT");

Budget : 256100 centimes HT

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
enum TypePoste {
    Fixe,
    Portable,
    Serveur,
}

#[derive(Debug, Clone, PartialEq, Default)]
struct Filtre {
    marque: Option<String>,
    prix_max: Option<u32>,
    seulement_en_stock: bool,
}

/// Un montant en centimes, pour ne plus confondre prix et quantités.
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
struct Centimes(u64);

impl From<u32> for Centimes {
    fn from(valeur: u32) -> Self {
        Centimes(u64::from(valeur))
    }
}

fn main() {
    let mut types = vec![TypePoste::Serveur, TypePoste::Fixe, TypePoste::Portable];
    types.sort(); // possible grâce à Ord : l'ordre de déclaration
    println!("{types:?}");

    let filtre = Filtre { prix_max: Some(100000), ..Default::default() };
    println!("{filtre:?}");

    let prix: Centimes = 89900_u32.into(); // into() s'appuie sur From
    println!("{prix:?} {}", prix > Centimes(50000));
}

[Fixe, Portable, Serveur]
Filtre { marque: None, prix_max: Some(100000), seulement_en_stock: false }
Centimes(89900) true

/// Un inventaire de n'importe quel type d'élément.
struct Inventaire<T> {
    elements: Vec<T>,
}

impl<T> Inventaire<T> {
    fn new() -> Self {
        Inventaire { elements: Vec::new() }
    }

    fn ajouter(&mut self, element: T) {
        self.elements.push(element);
    }

    fn taille(&self) -> usize {
        self.elements.len()
    }
}

/// Le plus grand élément, pour tout type comparable.
fn maximum<T: PartialOrd + Copy>(valeurs: &[T]) -> Option<T> {
    let mut resultat = *valeurs.first()?;
    for &v in valeurs {
        if v > resultat {
            resultat = v;
        }
    }
    Some(resultat)
}

fn main() {
    let mut numeros: Inventaire<&str> = Inventaire::new();
    numeros.ajouter("PC-0001");
    numeros.ajouter("PC-0002");
    let mut prix: Inventaire<u32> = Inventaire::new();
    prix.ajouter(89900);
    println!("{} numéros, {} prix", numeros.taille(), prix.taille());

    println!("{:?}", maximum(&[64900, 104900, 89900]));
    println!("{:?}", maximum(&[2.5, 1.0]));
    println!("{:?}", maximum::<i32>(&[]));
}

2 numéros, 1 prix
Some(104900)
Some(2.5)
None