/* Page prose (fr) */
"VersionBModern" = "# Version B (moderne): `async`/`await` + `async let`\n\nLa même tâche. Chaque récupération est maintenant une **fonction async** qui soit retourne une valeur, soit fait `throw`. Nous démarrons les deux avec **`async let`** pour qu'elles s'exécutent de façon concurrente, faisons `await` sur les deux ensemble, combinons, et laissons `@MainActor` nous placer sur le thread principal, sans saut manuel.";
"VersionBModern-2" = "**Observe l'exécution:** sortie identique:\n\n* callout(Sortie):\n`Fetching menu and stock...`  \n`Sellable today: [\"Latte\", \"Espresso\"]`\n\nEt le timing est identique lui aussi (les deux s'exécutent toujours en parallèle, ~0.6 s au total). La page Playground continue de s'exécuter pendant que la `Task` se termine.\n\n* callout(Essaie): Monte le sleep de `fetchMenu` à `.milliseconds(1200)`: le temps total suit la récupération *la plus lente*, pas la somme des deux. Quelle ligne s'affiche toujours en premier?\n\nMaintenant regarde ce qui a disparu:\n\n* **Aucune variable mutable partagée.** `menu` et `stock` ne sont que des valeurs.\n* **Aucun `enter`/`leave`.** `async let` démarre chaque enfant; `try await (menu, stock)` est la jonction. Il n'y a aucun compteur à équilibrer.\n* **Un seul chemin d'erreur.** Que `fetchMenu` ou `fetchStock` lève une erreur, cela atterrit dans l'unique `catch`. Tu n'as pas déballé deux optionnels, et tu n'as pas appelé `.get()`.\n* **Aucun saut manuel vers le thread principal.** Le `@MainActor` sur la fonction *est* la garantie. La combinaison et le `print` s'exécutent sur le main actor parce que la fonction lui est isolée. Oublier de revenir au principal n'est plus possible.\n\nLa logique, le `filter`, est maintenant la ligne la plus visible de la fonction, parce que tout ce qui l'entourait s'est écarté du chemin.\n\n---\n\n## Ressens la différence\n\n* **État mutable partagé.** Classique: deux variables `Result?`. Moderne: aucune.\n* **\"Attendre les deux.\"** Classique: `DispatchGroup` avec `enter`/`leave`. Moderne: `async let` avec `await`.\n* **Gestion des erreurs.** Classique: déballer les optionnels, puis `try`/`catch`. Moderne: un seul `try`/`catch`.\n* **Livraison sur le thread principal.** Classique: se souvenir de `notify(queue: .main)`. Moderne: `@MainActor`, automatique.\n* **Les lignes qui ne sont pas la tâche en soi.** Classique: beaucoup. Moderne: peu.\n* **Le compilateur attrape un saut vers le principal oublié.** Classique: non. Moderne: oui.\n\nLe même comportement, le même parallélisme, la même sortie, mais la B dit ce qu'elle *signifie* et laisse le compilateur imposer les parties que tu devais autrefois garder en tête. C'est là tout l'argument en faveur du modèle moderne, en un seul exemple.\n\n[Précédent](@previous)  |  page 4 sur 8  |  [Suivant: Classique et moderne en pratique](@next)";
