Relier Result à async/await

Les API historiques fondées sur des rappels renvoient `Result`. Le code moderne utilise async/await. Faire le lien entre les deux est une tâche courante : Swift propose des schémas clairs dans les deux sens.

```swift func fetchAsync(url: URL) async throws -> Data { try await withCheckedThrowingContinuation { cont in fetchCallback(url) { result in cont.resume(with: result) } } } ``` `cont.resume(with: result)` accepte directement un `Result`.

```swift func fetchAsync(url: URL) async -> Result { await withCheckedContinuation { cont in fetchCallback(url) { result in cont.resume(returning: result) } } } ```

```swift func asResult(of operation: () async throws -> T) async -> Result { do { return .success(try await operation()) } catch { return .failure(error) } } let r = await asResult { try await fetch(url) } ```

```swift func process() async { let result: Result = await fetchAsync(url) do { let data = try result.get() handle(data) } catch { handle(error) } } ```

```swift func load() { Task { let data = try await fetchAsync(url) await MainActor.run { self.render(data) } } } ```

```swift func events() -> AsyncStream { AsyncStream { cont in let token = subscribe { event in cont.yield(event) } cont.onTermination = { _ in unsubscribe(token) } } } ```

• Appelez `resume` exactement une fois : le comportement est indéfini si vous l’appelez deux fois • Ne reprenez pas l’exécution après le retour de la fonction • Utilisez `withCheckedContinuation` en mode débogage (pour détecter les erreurs) et `withUnsafeContinuation` en version finale si les performances l’exigent

```swift await MainActor.run { label.text = data.description } // or: @MainActor func updateUI(_ d: Data) { label.text = ... } await updateUI(data) ```

```swift func testFetch() async throws { let result = await asResult { try await fetchAsync(url) } switch result { case .success(let d): XCTAssertFalse(d.isEmpty) case .failure(let e): XCTFail(e.localizedDescription) } } ```

Points essentiels : • `withCheckedThrowingContinuation` relie les rappels au fonctionnement asynchrone avec gestion des erreurs • `cont.resume(with: result)` accepte directement un Result • Encapsulez l'asynchrone avec gestion des erreurs dans un `Result` à l'aide d'une fonction auxiliaire • Appelez `resume` exactement une fois • `MainActor.run { }` permet de mettre à jour l'interface en toute sécurité depuis un contexte asynchrone Cours terminé ! Suite : notions de base de SwiftUI.