Swift Concurrency Best Practices (Swift 6+)

1. Structured Concurrency

• Prefer async let for parallel tasks when the number of tasks is known.

• Use TaskGroup for a dynamic number of parallel tasks.

• Avoid Task { ... } (unstructured) unless bridging from synchronous code (e.g., UI event handlers) or firing background work that outlives the scope.

2. Actors & Isolation

• Default to @MainActor for all UI-related classes (ViewModels, SwiftUI Views).

• Use actor for shared mutable state that is not UI-related (e.g., caching, database managers).

• Global Actors: Use @MainActor or custom global actors to synchronize access across different types.

3. Sendability

• Strict Concurrency Checking: Assume Strict Concurrency is ON.

• Mark immutable structs/enums as Sendable (often implicit, but be explicit if public).

• For classes, use final and @unchecked Sendable only if you are manually managing thread safety (locks/queues). Ideally, use actor .

• Closures: Ensure closures passed between contexts are @Sendable .

4. Migration from Combine/Closures

• Replace DispatchQueue.main.async with await MainActor.run { ... } or isolate the function itself.

• Replace Future /Promise with direct async throws functions.

• Use AsyncStream to replace simple Combine PassthroughSubject scenarios.

Example: Safe ViewModel

@MainActor final class UserViewModel: ObservableObject { @Published var users: [User] = []

// Dependencies should be Sendable
private let client: APIClient

func load() async {
    do {
        // 'await' suspends, allowing other work on MainActor if needed
        self.users = try await client.fetchUsers()
    } catch {
        print(error)
    }
}

}