/* Page prose (fr) */
"Overview" = "# Continuations\n\nÀ ce stade, `await` te semble naturel, mais la plupart du code qui circule ne le parle pas. Les completion handlers classiques des chapitres précédents, chaque saut de `DispatchQueue`, chaque méthode delegate qui se déclenche \"plus tard\" (et d'innombrables APIs du système et de SDK que tu rencontreras dans de vrais projets) sont des APIs de **callback**, pas des APIs asynchrones. Tu ne peux pas saupoudrer `await` sur `fetchThing { ... }` en espérant que ça marche. Une **continuation** est l'adaptateur officiel: elle te laisse envelopper une de ces vieilles APIs de callback pour que le monde extérieur puisse l'appeler avec un `await` propre. Ce chapitre explique comment construire cet adaptateur à la main.\n\n---\n\n## Ce que tu vas apprendre\n\n* Ce qu'est une **continuation**, et pourquoi c'est le pont des callbacks vers `await`.\n* `withCheckedContinuation`: suspendre une fonction asynchrone, exécuter une API de callback, et **reprendre** quand le callback se déclenche.\n* `withCheckedThrowingContinuation` pour les APIs qui peuvent échouer, en enveloppant à la fois la forme `Result` et la forme classique `(valeur, erreur)`.\n* La seule règle que tu ne dois jamais enfreindre: **reprendre exactement une fois**, et comment les continuations \"checked\" t'attrapent quand tu déraps.\n* Comment faire le pont entre un callback à un seul déclenchement, de style **delegate**, et un seul appel asynchrone.\n\n---\n\n## Le pont dont tu as besoin\n\nVoici le décalage. Une fonction asynchrone progresse de haut en bas et **se suspend** à chaque `await`, rendant le thread jusqu'à ce que son résultat soit prêt. Une API de callback ne renvoie pas de résultat du tout: elle te remet une closure et l'appelle **plus tard**, depuis là où elle a terminé. Deux mondes différents.\n\nUne **continuation** est une valeur qui représente \"le reste de la fonction asynchrone suspendue, en attente qu'on lui remette un résultat.\" Tu en obtiens une, tu la ranges, tu appelles ta vieille API de callback, et quand le callback se déclenche tu **reprends** la continuation avec la valeur. Cette reprise est ce qui réveille la fonction asynchrone.\n\nLa forme est toujours la même:\n\n```swift\nfunc modernVersion() async -> Result {\n    await withCheckedContinuation { continuation in\n        oldCallbackAPI { value in                   // the callback fires later...\n            continuation.resume(returning: value)   // ...and wakes us up\n        }\n    }\n}\n```\n\nL'appel `await withCheckedContinuation { ... }` **se suspend** juste là. Il ne reviendra pas tant que *quelqu'un* n'appelle pas `continuation.resume(...)`. La closure que tu passes s'exécute immédiatement (c'est là que tu lances la vieille API), mais le `await` lui-même reste garé jusqu'à ce que la reprise arrive.\n\nÀ la page suivante, nous en construirons une vraie et la verrons se suspendre et reprendre.\n\npage 1 sur 8  |  [Suivant: Suspendre, puis reprendre](@next)";
