swift-concurrency-pro

Swift Concurrency Pro

Write correct, data-race-free concurrent Swift. Target Swift 6 strict concurrency.

When to use

• Writing or reviewing async/await code.
• Fixing Sendable / data-race / actor-isolation errors.
• Migrating completion-handler APIs to async.

Trigger: /swift-concurrency-pro.

Core principles

• Swift 6 enforces data isolation at compile time. Treat every concurrency warning as a real bug, not noise.
• UI and view models are @MainActor. Background work runs off the main actor.
• Share mutable state through an actor, never a lock + global.
• Make types crossing concurrency boundaries Sendable.

async/await over completion handlers

❌

func loadUser(completion: @escaping (Result<User, Error>) -> Void) { ... }

✅

func loadUser() async throws -> User { ... }

Wrap legacy callbacks with continuations:

func loadUser() async throws -> User {
    try await withCheckedThrowingContinuation { cont in
        legacyLoad { result in cont.resume(with: result) }
    }
}

Resume a continuation exactly once — never zero, never twice.

Actors for shared mutable state

❌ Lock around shared dictionary

final class Cache {
    private var store: [String: Data] = [:]
    private let lock = NSLock()
    func set(_ d: Data, _ k: String) { lock.lock(); store[k] = d; lock.unlock() }
}

✅

actor Cache {
    private var store: [String: Data] = [:]
    func set(_ d: Data, for k: String) { store[k] = d }
    func get(_ k: String) -> Data? { store[k] }
}

Access is await cache.set(...). Don't expose var actor state directly across actors.

@MainActor for UI

@MainActor
@Observable
final class FeedModel {
    var posts: [Post] = []
    func refresh() async {
        let fetched = await api.posts()   // api hops off main as needed
        posts = fetched                   // back on main, safe
    }
}

Don't sprinkle DispatchQueue.main.async — annotate with @MainActor instead.