/* Page prose (fr) */
"RunningWorkConcurrentlyWithAsyncLet" = "# Exécuter du travail de façon concurrente avec `async let`\n\nC'est ici qu'async/await commence à porter ses fruits. Suppose qu'un latte nécessite deux étapes lentes: faire mousser le lait *et* extraire le shot. Chacune prend environ une seconde. Chronométrons d'abord la version évidente:";
"RunningWorkConcurrentlyWithAsyncLet-2" = "Ces deux await s'exécutent **séquentiellement**: chaque `await` se termine complètement avant que la ligne suivante ne commence. Le lait mousse (1 s), et seulement *ensuite* le shot démarre (encore 1 s). Total: environ **2 secondes**. Mais faire mousser le lait et extraire un shot ne dépendent pas l'un de l'autre; un vrai barista les ferait en même temps.\n\n`async let` te permet de dire exactement ça. Il **démarre** le travail asynchrone immédiatement et lie le résultat éventuel à un nom; tu fais `await` sur ce nom seulement quand tu as réellement besoin de la valeur:";
"RunningWorkConcurrentlyWithAsyncLet-3" = "Les deux lignes `async let` lancent les deux morceaux de travail coup sur coup, sans attendre. Le temps que tu arrives au `await` de la ligne suivante, ils ont moussé et extrait *en parallèle* tout ce temps.\n\n**Observe l'exécution:** cette page affiche `Concurrent total: 1.0x s`. Compare ça avec la version séquentielle ci-dessus, qui affiche `Sequential total: 2.0x s`, les deux attentes d'une seconde empilées au lieu de se chevaucher.\n\nVoilà le titre: **deux tâches d'une seconde se terminent en ~1 s, pas ~2 s.** Tu n'as pas ajouté de threads ni de files à la main; tu as simplement dit à Swift quel travail était indépendant, et il a chevauché l'attente pour toi. Les chiffres de temps écoulé ne seront pas exactement `1.00` ou `2.00` (il y a un peu de surcoût), mais le quasi-doublement est indéniable.\n\n> **Pourquoi `async let` et pas deux `await`?** Un simple `await` *attend* là où il se trouve, donc le deuxième appel ne peut pas commencer tant que le premier n'a pas retourné. `async let` *démarre* le travail et diffère l'attente, ce qui permet à deux tâches indépendantes de s'exécuter en même temps. Utilise-le chaque fois que tu as du travail qui ne dépend pas des résultats de l'autre.\n\nC'est ton premier aperçu de la **concurrence structurée**: démarrer plusieurs morceaux de travail et rassembler leurs résultats dans une portée claire. `async let` gère bien deux ou trois morceaux fixes. Quand tu as toute une *collection* de travail (disons, dix boissons à la fois), tu voudras un **`TaskGroup`**, qui est le sujet du chapitre [Task Groups](Task%20Groups.playgroundchapter/Overview). Et les détails de `Task` lui-même viennent d'abord, dans le chapitre [Tâches et annulation](Tasks%20and%20Cancellation.playgroundchapter/Overview).\n\n* callout(Essaie): Change le délai de `pullShot()` à `.seconds(2)` et laisse `steamMilk()` à `.seconds(1)`, quel est le total concurrent maintenant, et quelle étape le décide?\n\n[Précédent](@previous)  |  page 7 sur 8  |  [Suivant: Récapitulatif](@next)";
