Łączenie Result z async/await

Starsze API oparte na callbackach zwracają `Result`. Nowoczesny kod korzysta z async/await. Łączenie obu podejść jest częstym zadaniem — Swift udostępnia przejrzyste wzorce dla obu kierunków.

```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)` bezpośrednio przyjmuje wartość typu `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) } } } ```

• Wywołuj `resume` dokładnie raz — dwukrotne wywołanie powoduje niezdefiniowane zachowanie • Nie wywołuj `resume` po zakończeniu działania funkcji • Używaj `withCheckedContinuation` w trybie debugowania (wykrywa błędy), a w razie potrzeby `withUnsafeContinuation` w wersji produkcyjnej, aby poprawić wydajność

```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) } } ```

Najważniejsze informacje: • `withCheckedThrowingContinuation` łączy callbacki z async throws • `cont.resume(with: result)` przyjmuje bezpośrednio typ Result • Należy opakować `async throws` w `Result` za pomocą funkcji pomocniczej • Wywołuj `resume` dokładnie raz • `MainActor.run { }` służy do bezpiecznych aktualizacji interfejsu użytkownika z kontekstu asynchronicznego Kurs ukończony! Następnie: podstawy SwiftUI.