dpearson2699/swift-ios-skills / skills/swift-concurrency
swift-concurrency
VerifiedResolve Swift concurrency compiler errors, adopt approachable concurrency (SE-0466), and write data-race-safe async code. Use when fixing Sendable conformance errors, actor isolation warnings, or strict concurrency diagnostics; when adopting default MainActor isolation, @concurrent, nonisolated(nonsending), or Task.immediate; when designing actor-based architectures, structured concurrency with TaskGroup, or background work offloading; or when migrating from @preconcurrency to full Swift 6 strict concurrency.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 19.5 KB |
| evals/evals.json | config | 8.4 KB |
| references/approachable-concurrency.md | markdown | 3.9 KB |
| references/async-algorithms.md | markdown | 2.6 KB |
| references/bridging-interop.md | markdown | 9.1 KB |
| references/concurrency-patterns.md | markdown | 8.5 KB |
| references/diagnostics.md | markdown | 4.2 KB |
| references/swiftui-concurrency.md | markdown | 5.1 KB |
| references/synchronization-primitives.md | markdown | 13.6 KB |
references/async-algorithms.md
View on GitHub# Swift Async Algorithms
[swift-async-algorithms](https://github.com/apple/swift-async-algorithms) is an Apple open-source package providing `AsyncSequence` algorithms modeled after the standard library's `Sequence` algorithms.
## Contents
- [Key Algorithms](#key-algorithms)
- [Common Patterns](#common-patterns)
Add to Package.swift:
```swift
.package(url: "https://github.com/apple/swift-async-algorithms", from: "1.0.0")
```
## Key Algorithms
### Combining
```swift
import AsyncAlgorithms
// Merge multiple sequences into one (interleaved by arrival time)
for await value in merge(streamA, streamB) {
handle(value)
}
// Combine latest values from two sequences (emits when either updates)
for await (a, b) in combineLatest(streamA, streamB) {
handle(a, b)
}
// Zip — pairs elements 1:1 (waits for both)
for await (a, b) in zip(streamA, streamB) {
handle(a, b)
}
// Chain — concatenate sequences end-to-end
for await value in chain(streamA, streamB) {
handle(value)
}
```
### Temporal
```swift
// Debounce — emit after a quiet period (e.g., search-as-you-type)
let searchResults = searchTerms
.debounce(for: .milliseconds(300))
for await term in searchResults {
await performSearch(term)
}
// Throttle — emit at most once per interval
let throttled = sensorReadings
.throttle(for: .seconds(1))
for await reading in throttled {
updateDisplay(reading)
}
// Chunks — collect elements into arrays by count or time
for await batch in events.chunks(ofCount: 10) {
await processBatch(batch) // [Event] with up to 10 elements
}
for await batch in events.chunked(by: .repeating(every: .seconds(1))) {
await processBatch(batch)
}
```
### Filtering and Transformation
```swift
// Remove consecutive duplicates
for await value in stream.removeDuplicates() {
handle(value)
}
// Compacted — remove nils (like compactMap without transform)
let values: AsyncStream<Int?> = ...
for await value in values.compacted() {
// value is non-optional Int
}
```
## Common Patterns
### Search-as-you-type
```swift
func searchResults(for terms: AsyncStream<String>) -> AsyncStream<[Result]> {
AsyncStream { continuation in
Task {
for await term in terms.debounce(for: .milliseconds(300)) {
guard !Task.isCancelled else { break }
let results = try? await searchService.search(term)
continuation.yield(results ?? [])
}
continuation.finish()
}
}
}
```
### Rate-limited API calls
```swift
for await batch in requestStream.chunks(ofCount: 50).throttle(for: .seconds(1)) {
await api.sendBatch(batch)
}
```
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| brainstormingobra/superpowersYou MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation). | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| brand-guidelinesanthropics/skillsApplies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| frontend-designanthropics/skillsGuidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| mcp-builderanthropics/skillsGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK). | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |