Paradigmes : correction en spoiler MkDocs + Récursivité : renommage EXERCICES.md

Paradigmes/README.md

@@ -244,6 +244,211 @@ Voici une tâche simple : nous voulons faire cuire des pâtes.
 - **Version fonctionnelle : une fonction pure qui prend un état (pâtes non cuites) et retourne un nouvel état (pâtes cuites).**
 - **Version orientée objet : créer une classe** Pates *avec une méthode* cuire().
 
+??? success "Correction"
+
+    ## Version impérative
+
+    Liste d’instructions étape par étape, avec modification d’état.
+
+    ```python
+    def cuire_pates_imperatif():
+        """Fait cuire des pâtes de manière impérative."""
+
+        eau = "froide"
+        pates = "crues"
+        sel = False
+
+        print("Remplissage de la casserole...")
+        quantite_eau = 1.5
+
+        print("Chauffage de l’eau...")
+        eau = "chaude"
+
+        print("Attente de l’ébullition...")
+        eau = "bouillante"
+
+        print("Ajout du sel...")
+        sel = True
+
+        print("Ajout des pâtes...")
+        pates = "en cuisson"
+
+        temps_cuisson = 10
+        print(f"Cuisson pendant {temps_cuisson} minutes...")
+
+        print("Égouttage des pâtes...")
+        pates = "cuites"
+
+        print(f"Résultat : pâtes {pates}")
+        return pates
+
+    resultat = cuire_pates_imperatif()
+    ```
+
+    **Caractéristiques :**
+
+    - Modification d’état (variables `eau`, `pates`, `sel`)
+    - Instructions séquentielles
+    - Effets de bord (print)
+
+    ---
+
+    ## Version fonctionnelle
+
+    Une fonction pure qui prend un état et retourne un nouvel état, sans modification.
+
+    ```python
+    def remplir_casserole(etat):
+        return {**etat, "eau": "froide", "quantite_eau": 1.5}
+
+    def chauffer_eau(etat):
+        return {**etat, "eau": "chaude"}
+
+    def faire_bouillir(etat):
+        return {**etat, "eau": "bouillante"}
+
+    def saler(etat):
+        return {**etat, "sel": True}
+
+    def ajouter_pates(etat):
+        return {**etat, "pates": "en cuisson"}
+
+    def cuire(etat, duree):
+        return {**etat, "temps_cuisson": duree, "pates": "cuites"}
+
+    def egoutter(etat):
+        return {**etat, "egouttees": True}
+
+    def cuire_pates_fonctionnel(etat_initial):
+        etat = remplir_casserole(etat_initial)
+        etat = chauffer_eau(etat)
+        etat = faire_bouillir(etat)
+        etat = saler(etat)
+        etat = ajouter_pates(etat)
+        etat = cuire(etat, 10)
+        etat = egoutter(etat)
+        return etat
+
+    etat_initial = {"pates": "crues", "sel": False}
+    resultat = cuire_pates_fonctionnel(etat_initial)
+    print(f"État final : {resultat}")
+    print(f"État initial préservé : {etat_initial}")
+    ```
+
+    **Caractéristiques :**
+
+    - Pas de modification d’état (immutabilité)
+    - Fonctions pures (même entrée → même sortie)
+    - Composition de fonctions
+    - L’état initial n’est jamais modifié
+
+    ---
+
+    ## Version orientée objet
+
+    Une classe `Pates` avec des attributs et une méthode `cuire()`.
+
+    ```python
+    class Casserole:
+        def __init__(self):
+            self.eau = None
+            self.temperature = "froide"
+            self.sel = False
+
+        def remplir(self, quantite=1.5):
+            self.eau = quantite
+            print(f"Casserole remplie avec {quantite}L d’eau")
+
+        def chauffer(self):
+            self.temperature = "bouillante"
+            print("L’eau bout !")
+
+        def saler(self):
+            self.sel = True
+            print("Sel ajouté")
+
+
+    class Pates:
+        def __init__(self, type_pates="spaghetti", quantite=500):
+            self.type = type_pates
+            self.quantite = quantite
+            self.etat = "crues"
+            self.temps_cuisson = 0
+
+        def cuire(self, casserole, duree=10):
+            if casserole.eau is None:
+                raise ValueError("La casserole doit contenir de l’eau !")
+            if casserole.temperature != "bouillante":
+                raise ValueError("L’eau doit être bouillante !")
+            self.etat = "en cuisson"
+            self.temps_cuisson = duree
+            self.etat = "cuites"
+            print(f"Les {self.type} sont cuites !")
+
+        def egoutter(self):
+            if self.etat != "cuites":
+                raise ValueError("Les pâtes doivent être cuites avant d’être égouttées !")
+            self.etat = "prêtes"
+
+        def __str__(self):
+            return f"Pates({self.type}, {self.quantite}g, état={self.etat})"
+
+
+    casserole = Casserole()
+    pates = Pates("fusilli", 400)
+    casserole.remplir(2.0)
+    casserole.chauffer()
+    casserole.saler()
+    pates.cuire(casserole, duree=12)
+    pates.egoutter()
+    print(f"Fin : {pates}")
+    ```
+
+    **Caractéristiques :**
+
+    - Encapsulation (attributs et méthodes regroupés)
+    - Objets avec état interne
+    - Interactions entre objets (Pates et Casserole)
+
+    ---
+
+    ## Tableau comparatif
+
+    | Aspect | Impératif | Fonctionnel | Orienté Objet |
+    |--------|-----------|-------------|---------------|
+    | **État** | Variables modifiées | États immuables | Attributs d’objets |
+    | **Données** | Variables simples | Dictionnaires/tuples | Objets |
+    | **Actions** | Instructions séquentielles | Fonctions composées | Méthodes |
+    | **Modification** | Sur place | Nouvel état retourné | Via méthodes |
+    | **Réutilisabilité** | Faible | Moyenne | Forte |
+    | **Testabilité** | Difficile | Facile | Moyenne |
+
+    ---
+
+    ## Bonus : version lambda
+
+    ```python
+    import functools
+
+    etapes = [
+        lambda e: {**e, "eau": 1.5},
+        lambda e: {**e, "temperature": "bouillante"},
+        lambda e: {**e, "sel": True},
+        lambda e: {**e, "pates": "en cuisson"},
+        lambda e: {**e, "temps": 10, "pates": "cuites"},
+        lambda e: {**e, "egouttees": True}
+    ]
+
+    cuire_pates_lambda = lambda etat: functools.reduce(
+        lambda e, f: f(e),
+        etapes,
+        etat
+    )
+
+    resultat = cuire_pates_lambda({"pates": "crues"})
+    print(resultat)
+    ```
+
 ------
 
 Auteurs : Florian Mathieu, Enzo Frémeaux, Thimothée Decooster