Swift Lang

Concurrency

When: async/await patterns, actor isolation, Sendable conformance, data race prevention References:

• references/concurrency/async-await.md - Structured concurrency patterns
• references/concurrency/actors.md - Actor isolation, @MainActor
• references/concurrency/sendable.md - Sendable conformance, crossing isolation boundaries

Testing

When: Writing tests with Swift Testing framework, test strategies References:

• references/testing/swift-testing.md - @Test, #expect, traits, parameterized tests
• references/testing/strategies.md - What to test, dependency injection for testing

Generics

When: Protocol design, associated types, existentials, type erasure References:

• references/generics/protocols.md - Associated types, primary associated types
• references/generics/existentials.md - any vs some, type erasure patterns

Optimization

When: Memory management, performance profiling, reducing allocations References:

• references/optimization/memory.md - ARC, weak/unowned, copy-on-write
• references/optimization/performance.md - Instruments, allocation patterns

Result Builders

When: Building custom DSLs, understanding @ViewBuilder internals References:

• references/result-builders/custom-dsl.md - Building your own @resultBuilder

Networking

When: Making HTTP requests, API clients, async data fetching References:

• references/networking/async-networking.md - URLSession with async/await, API client patterns

Key Patterns:

• Async/await with URLSession
• Actor-based API clients
• Authentication and retry logic
• Concurrent requests with async let
• Error handling and cancellation

Quick Reference

Macro Package Setup

// Package.swift for macro development
// swift-tools-version: 5.9
import PackageDescription
import CompilerPluginSupport

let package = Package(
    name: "MyMacros",
    platforms: [.macOS(.v10_15), .iOS(.v13)],
    products: [
        .library(name: "MyMacros", targets: ["MyMacros"]),
    ],
    dependencies: [
        .package(url: "https://github.com/apple/swift-syntax.git", from: "509.0.0"),
    ],
    targets: [
        .macro(
            name: "MyMacrosMacros",
            dependencies: [
                .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
                .product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
            ]
        ),
        .target(name: "MyMacros", dependencies: ["MyMacrosMacros"]),
    ]
)

Concurrency Essentials

// Structured concurrency
func fetchData() async throws -> Data {
    try await withThrowingTaskGroup(of: Data.self) { group in
        // Add tasks to group
    }
}

// Actor isolation
@MainActor
class ViewModel: ObservableObject {
    @Published var items: [Item] = []
}

// Sendable conformance
struct Config: Sendable {
    let apiKey: String
}

Swift Testing

import Testing

@Test("User authentication succeeds with valid credentials")
func validLogin() async throws {
    let auth = AuthService()
    let result = try await auth.login(user: "test", pass: "valid")
    #expect(result.isAuthenticated)
}

@Test(arguments: ["", "ab", "toolong123"])
func invalidUsername(_ username: String) {
    #expect(!Validator.isValidUsername(username))
}

Anti-Patterns

• Force unwrapping in production code
• Ignoring actor isolation warnings
• Using nonisolated(unsafe) without understanding implications
• Massive macro implementations (split into helpers)
• Testing implementation details instead of behavior

Related Skills

• swift-ui - SwiftUI view patterns and architecture
• design-review - App Store submission prep