Design patterns

from operator import attrgetter
from typing import Callable

Tri = Callable[[Article], object]        # Python trie par clé, pas par comparaison

par_prix = attrgetter("prix")
par_nom = attrgetter("nom")


class Catalogue:
    def __init__(self, articles: list[Article]) -> None:
        self._articles = articles

    def trier(self, strategie: Tri) -> list[Article]:
        return sorted(self._articles, key=strategie)

use std::cmp::Ordering;

type Tri = fn(&Article, &Article) -> Ordering;

fn par_prix(a: &Article, b: &Article) -> Ordering { a.prix.cmp(&b.prix) }
fn par_nom(a: &Article, b: &Article) -> Ordering { a.nom.cmp(&b.nom) }

struct Catalogue {
    articles: Vec<Article>,
}

impl Catalogue {
    fn trier(&self, strategie: Tri) -> Vec<Article> {
        let mut copie = self.articles.clone();
        copie.sort_by(strategie);
        copie
    }
}

from typing import Callable, Generic, TypeVar

T = TypeVar("T")


class Sujet(Generic[T]):
    def __init__(self) -> None:
        self._observateurs: list[Callable[[T], None]] = []

    def souscrire(self, observateur: Callable[[T], None]) -> Callable[[], None]:
        self._observateurs.append(observateur)
        return lambda: self._observateurs.remove(observateur)   # Désinscription

    def emettre(self, valeur: T) -> None:
        for observateur in list(self._observateurs):            # Copie : la liste
            observateur(valeur)                                 # peut changer

type Abonnement = u64;

struct Sujet<T> {
    observateurs: Vec<(Abonnement, Box<dyn Fn(&T)>)>,
    prochain_id: Abonnement,
}

impl<T> Sujet<T> {
    fn souscrire(&mut self, observateur: impl Fn(&T) + 'static) -> Abonnement {
        let id = self.prochain_id;
        self.prochain_id += 1;
        self.observateurs.push((id, Box::new(observateur)));
        id                              // Deux closures n'étant pas comparables,
    }                                   // la désinscription passe par un jeton

    fn desinscrire(&mut self, id: Abonnement) {
        self.observateurs.retain(|(autre, _)| *autre != id);
    }

    fn emettre(&self, valeur: &T) {
        for (_, observateur) in &self.observateurs {
            observateur(valeur);
        }
    }
}

from pathlib import Path


def creer_parseur(fichier: str) -> Parseur:
    match Path(fichier).suffix:
        case ".json": return ParseurJson()
        case ".csv":  return ParseurCsv()
        case ".xml":  return ParseurXml()
        case autre:   raise ValueError(f"Format inconnu : {autre}")

fn creer_parseur(fichier: &str) -> Result<Box<dyn Parseur>, FormatInconnu> {
    match fichier.rsplit_once('.') {
        Some((_, "json")) => Ok(Box::new(ParseurJson)),
        Some((_, "csv"))  => Ok(Box::new(ParseurCsv)),
        Some((_, "xml"))  => Ok(Box::new(ParseurXml)),
        _ => Err(FormatInconnu(fichier.to_owned())),
    }
}

from typing import Protocol

# Le domaine veut ceci.


class PasserelleDePaiement(Protocol):
    def debiter(self, montant_en_centimes: int, carte: Carte) -> Recu: ...


# Le prestataire fournit cela.


class StripeAdapter:
    def __init__(self, stripe: StripeSdk) -> None:
        self._stripe = stripe

    def debiter(self, montant_en_centimes: int, carte: Carte) -> Recu:
        intent = self._stripe.PaymentIntent.create(
            amount=montant_en_centimes,
            currency="eur",
            payment_method=carte.token,
        )
        return Recu(
            reference=intent.id,
            statut="ok" if intent.status == "succeeded" else "ko",
        )

// Le domaine veut ceci.
trait PasserelleDePaiement {
    fn debiter(&self, montant_en_centimes: u64, carte: &Carte) -> Result<Recu, Erreur>;
}

// Le prestataire fournit cela.
struct StripeAdapter {
    stripe: StripeSdk,
}

impl PasserelleDePaiement for StripeAdapter {
    fn debiter(&self, montant_en_centimes: u64, carte: &Carte) -> Result<Recu, Erreur> {
        let intent = self.stripe.creer_payment_intent(PaymentIntentParams {
            amount: montant_en_centimes,
            currency: "eur",
            payment_method: &carte.token,
        })?;

        Ok(Recu {
            reference: intent.id,
            statut: match intent.status.as_str() {
                "succeeded" => Statut::Ok,
                _ => Statut::Ko,
            },
        })
    }
}

from time import perf_counter
from typing import Protocol


class Depot(Protocol):
    def lire(self, cle: str) -> str: ...


class DepotAvecCache:
    def __init__(self, source: Depot) -> None:
        self._source = source
        self._cache: dict[str, str] = {}

    def lire(self, cle: str) -> str:
        if cle not in self._cache:
            self._cache[cle] = self._source.lire(cle)
        return self._cache[cle]


class DepotAvecJournal:
    def __init__(self, source: Depot) -> None:
        self._source = source

    def lire(self, cle: str) -> str:
        debut = perf_counter()
        valeur = self._source.lire(cle)
        print(f"{cle} : {perf_counter() - debut:.3f}s")
        return valeur


depot = DepotAvecJournal(DepotAvecCache(DepotS3()))

use std::cell::RefCell;
use std::collections::HashMap;
use std::time::Instant;

trait Depot {
    fn lire(&self, cle: &str) -> String;
}

struct DepotAvecCache<D: Depot> {
    source: D,
    cache: RefCell<HashMap<String, String>>,   // &self impose la mutabilité interne
}

impl<D: Depot> Depot for DepotAvecCache<D> {
    fn lire(&self, cle: &str) -> String {
        if let Some(valeur) = self.cache.borrow().get(cle) {
            return valeur.clone();
        }
        let valeur = self.source.lire(cle);
        self.cache.borrow_mut().insert(cle.to_owned(), valeur.clone());
        valeur
    }
}

struct DepotAvecJournal<D: Depot> {
    source: D,
}

impl<D: Depot> Depot for DepotAvecJournal<D> {
    fn lire(&self, cle: &str) -> String {
        let debut = Instant::now();
        let valeur = self.source.lire(cle);
        println!("{cle} : {:?}", debut.elapsed());
        valeur
    }
}

let depot = DepotAvecJournal {
    source: DepotAvecCache {
        source: DepotS3,
        cache: RefCell::default(),
    },
};

class ServiceInscription:                    # Façade
    def __init__(
        self,
        utilisateurs: UtilisateurRepository,
        courriels: Mailer,
        analytique: Tracker,
    ) -> None:
        self._utilisateurs = utilisateurs
        self._courriels = courriels
        self._analytique = analytique

    def inscrire(self, formulaire: Formulaire) -> Utilisateur:
        utilisateur = self._utilisateurs.creer(formulaire)
        self._courriels.envoyer_bienvenue(utilisateur)
        self._analytique.evenement("inscription", utilisateur.id)
        return utilisateur

struct ServiceInscription {          // Façade
    utilisateurs: Box<dyn UtilisateurRepository>,
    courriels: Box<dyn Mailer>,
    analytique: Box<dyn Tracker>,
}

impl ServiceInscription {
    fn inscrire(&self, formulaire: Formulaire) -> Result<Utilisateur, Erreur> {
        let utilisateur = self.utilisateurs.creer(formulaire)?;
        self.courriels.envoyer_bienvenue(&utilisateur)?;
        self.analytique.evenement("inscription", utilisateur.id);
        Ok(utilisateur)
    }
}

import os
from dataclasses import dataclass
from functools import lru_cache


@dataclass(frozen=True)
class Configuration:
    valeurs: dict[str, str]


@lru_cache(maxsize=1)
def configuration() -> Configuration:
    return Configuration(dict(os.environ))


# Un module Python n'étant importé qu'une fois, une simple variable de module est
# déjà un singleton — le patron s'écrit rarement en toutes lettres.

use std::collections::HashMap;
use std::sync::OnceLock;

struct Configuration {
    valeurs: HashMap<String, String>,
}

fn configuration() -> &'static Configuration {
    static INSTANCE: OnceLock<Configuration> = OnceLock::new();
    INSTANCE.get_or_init(|| Configuration {
        valeurs: std::env::vars().collect(),
    })
}

from abc import ABC, abstractmethod


class ImportCsv(ABC):
    def importer(self, fichier: str) -> Rapport:        # La méthode « patron »
        lignes = self._lire(fichier)
        valides = [l for l in lignes if self._valider(l)]
        for ligne in valides:
            self._enregistrer(ligne)
        return Rapport(total=len(lignes), importes=len(valides))

    def _lire(self, fichier: str) -> list[Ligne]:
        ...                                             # Commun à tous

    @abstractmethod
    def _valider(self, ligne: Ligne) -> bool: ...       # À fournir

    @abstractmethod
    def _enregistrer(self, ligne: Ligne) -> None: ...   # À fournir

trait ImportCsv {
    fn importer(&self, fichier: &str) -> Rapport {      // La méthode « patron »
        let lignes = self.lire(fichier);
        let valides: Vec<&Ligne> = lignes.iter().filter(|l| self.valider(l)).collect();
        for ligne in &valides {
            self.enregistrer(ligne);
        }
        Rapport { total: lignes.len(), importes: valides.len() }
    }

    fn lire(&self, fichier: &str) -> Vec<Ligne> {
        /* commun à tous */
    }

    fn valider(&self, ligne: &Ligne) -> bool;           // À fournir
    fn enregistrer(&self, ligne: &Ligne);               // À fournir
}

from typing import Protocol


class Commande(Protocol):
    def executer(self) -> None: ...
    def annuler(self) -> None: ...


class Historique:
    def __init__(self) -> None:
        self._pile: list[Commande] = []

    def lancer(self, commande: Commande) -> None:
        commande.executer()
        self._pile.append(commande)

    def defaire(self) -> None:
        if self._pile:
            self._pile.pop().annuler()

trait Commande {
    fn executer(&self, doc: &mut Document);   // La cible est explicite : aucune
    fn annuler(&self, doc: &mut Document);    // commande ne détient le document
}

struct Historique {
    pile: Vec<Box<dyn Commande>>,
}

impl Historique {
    fn lancer(&mut self, commande: Box<dyn Commande>, doc: &mut Document) {
        commande.executer(doc);
        self.pile.push(commande);
    }

    fn defaire(&mut self, doc: &mut Document) {
        if let Some(commande) = self.pile.pop() {
            commande.annuler(doc);
        }
    }
}

(
    RequeteBuilder()
    .table("commandes")
    .ou("statut", "validee")
    .trier_par("date", "desc")
    .limite(20)
    .construire()
)

# Les arguments nommés à valeur par défaut couvrent déjà la plupart des cas :
requete(table="commandes", tri=("date", "desc"), limite=20)

RequeteBuilder::new()
    .table("commandes")
    .ou("statut", "validee")
    .trier_par("date", Ordre::Desc)
    .limite(20)
    .construire();

// Chaque méthode consomme et renvoie `self` : la valeur intermédiaire n'est
// plus utilisable, et oublier `construire()` déclenche un avertissement.

from typing import Protocol


class Noeud(Protocol):
    def taille(self) -> int: ...


class Fichier:
    def __init__(self, octets: int) -> None:
        self._octets = octets

    def taille(self) -> int:
        return self._octets


class Dossier:
    def __init__(self, enfants: list[Noeud]) -> None:
        self._enfants = enfants

    def taille(self) -> int:
        return sum(enfant.taille() for enfant in self._enfants)

enum Noeud {
    Fichier(u64),
    Dossier(Vec<Noeud>),
}

impl Noeud {
    fn taille(&self) -> u64 {
        match self {
            Noeud::Fichier(octets) => *octets,
            Noeud::Dossier(enfants) => enfants.iter().map(Noeud::taille).sum(),
        }
    }
}

from typing import Iterator


class Arbre:
    def __init__(self, racine: Noeud) -> None:
        self._racine = racine

    def __iter__(self) -> Iterator[int]:
        yield from self._parcourir(self._racine)     # Parcours paresseux

    def _parcourir(self, n: Noeud) -> Iterator[int]:
        yield n.valeur
        for enfant in n.enfants:
            yield from self._parcourir(enfant)


for valeur in Arbre(racine):
    ...

struct Parcours<'a> {
    pile: Vec<&'a Noeud>,          // L'état du parcours, écrit à la main
}

impl<'a> Iterator for Parcours<'a> {
    type Item = u32;

    fn next(&mut self) -> Option<u32> {
        let noeud = self.pile.pop()?;
        self.pile.extend(noeud.enfants.iter().rev());
        Some(noeud.valeur)
    }
}

impl Noeud {
    fn iter(&self) -> Parcours<'_> {
        Parcours { pile: vec![self] }
    }
}

for valeur in racine.iter() { /* ... */ }

from typing import Protocol


class EtatCommande(Protocol):
    def payer(self, c: Contexte) -> None: ...
    def expedier(self, c: Contexte) -> None: ...


class EnAttente:
    def payer(self, c: Contexte) -> None:
        c.etat = Payee()

    def expedier(self, c: Contexte) -> None:
        raise RuntimeError("Commande non payée")

trait EtatCommande {
    fn payer(self: Box<Self>) -> Result<Box<dyn EtatCommande>, Interdit>;
    fn expedier(self: Box<Self>) -> Result<Box<dyn EtatCommande>, Interdit>;
}

struct EnAttente;
struct Payee;

impl EtatCommande for EnAttente {
    fn payer(self: Box<Self>) -> Result<Box<dyn EtatCommande>, Interdit> {
        Ok(Box::new(Payee))
    }

    fn expedier(self: Box<Self>) -> Result<Box<dyn EtatCommande>, Interdit> {
        Err(Interdit("Commande non payée"))
    }
}

from typing import Protocol


class FabriqueSql(Protocol):
    def connexion(self) -> Connexion: ...
    def constructeur_requete(self) -> RequeteBuilder: ...  # Le dialecte doit
                                                           # correspondre

class FabriquePostgres: ...
class FabriqueMySql: ...

trait FabriqueSql {
    type Connexion: Connexion;
    type Requete: RequeteBuilder;          // Types associés : la cohérence de la
                                           // famille est vérifiée à la compilation
    fn connexion(&self) -> Self::Connexion;
    fn constructeur_requete(&self) -> Self::Requete;
}

struct FabriquePostgres;
struct FabriqueMySql;