Pipelines de fonctions

Voici les implémentations avec correction de la collision de nom :

class Pipelinable:
    """
    Enveloppe une valeur pour permettre des appels en chaîne.
    """
    def __init__(self, valeur):
        self._valeur = valeur
    
    def a(self, f):
        """Applique une fonction et retourne un nouveau Pipelinable."""
        return Pipelinable(f(self._valeur))
    
    def valeur(self):
        """Retourne la valeur finale."""
        return self._valeur

# Version fonctionnelle simplifiée
def pipe(valeur, *fonctions):
    """
    Applique une série de fonctions à une valeur de départ.
    """
    resultat = valeur
    for f in fonctions:
        resultat = f(resultat)
    return resultat

# Version pédagogique chainable avec surcharge
def chainer(valeur):
    """Démarre une chaîne d'appels."""
    class Chainable:
        def __init__(self, val):
            self._val = val
        def __call__(self, f):
            return Chainable(f(self._val))
        def val(self):
            return self._val
    return Chainable(valeur)

# Tests avec pipe
print(pipe(5, lambda x: x + 1, lambda x: x * 2, lambda x: x ** 2))
# (5+1)=6, 6*2=12, 12^2=144

# Tests avec l'approche chaînée
resultat = (chainer(5)
            (lambda x: x + 1)
            (lambda x: x * 2)
            (lambda x: x ** 2)
            .val())
print(resultat)  # 144

# Exemple concret : pipeline de traitement de texte
texte = "  Bonjour le Monde  "
traite = pipe(texte,
              lambda s: s.strip(),           # Supprime espaces
              lambda s: s.lower(),           # Minuscules
              lambda s: s.replace(" ", "_"), # Remplace espaces par _
              lambda s: s.upper())           # Majuscules
print(traite)  # "BONJOUR_LE_MONDE"