concurrency-patterns_skill

Overview

This skill provides practical Swift concurrency patterns focused on Swift 6.2 approachable concurrency, structured concurrency, actors, continuations, and migration strategies. It helps you review or build async code, fix data races and actor isolation errors, and migrate code to Swift 6 strict concurrency with minimal disruption.

How this skill works

I inspect compiler errors, runtime data races, and code structure to identify the right concurrency construct: async/await, TaskGroup, actors, continuations, or Swift 6.2 features like @concurrent and isolated conformances. I apply a decision tree to match the problem to patterns and a checklist to verify thread safety, Sendable conformance, cancellation handling, and proper continuation usage.

When to use it

• You see data race errors, actor isolation compiler errors, or crashes tied to shared state.
• You are migrating code to Swift 6 strict concurrency or adopting Swift 6.2 features.
• You need to convert completion-handler or delegate APIs to async/await safely.
• You want to run work in parallel with structured concurrency (async let, TaskGroup).
• You need to protect mutable shared state using actors or @MainActor for UI updates.

Best practices

• Keep UI work on @MainActor and avoid blocking calls there; use await for long operations.
• Protect shared mutable state with actors rather than locks or global queues.
• Prefer structured concurrency (async let, withTaskGroup) over unstructured Task {} for lifetime control.
• Ensure Sendable conformance for types crossing isolation boundaries and check for inadvertent captures.
• Handle Task cancellation explicitly using Task.isCancelled or Task.checkCancellation().
• Use withCheckedContinuation and AsyncStream carefully: call continuations exactly once and clean up delegate bridges.

Example use cases

• Migrate a view model to Swift 6 by marking UI state @MainActor and adjusting isolated conformances.
• Fix intermittent crashes by converting a shared mutable cache to an actor and auditing Sendable types.
• Parallelize multiple network requests using async let or withTaskGroup and aggregate results safely.
• Bridge a legacy delegate-based API to async/await using withCheckedContinuation or AsyncStream.
• Adopt Swift 6.2 @concurrent for explicit background work and apply isolated conformances to @MainActor types.