Swift Expert

1---2name: swift-expert3description: Builds iOS/macOS/watchOS/tvOS applications, implements SwiftUI views and state management, designs protocol-oriented architectures, handles async/await concurrency, implements actors for thread safety, and debugs Swift-specific issues. Use when building iOS/macOS applications with Swift 5.9+, SwiftUI, or async/await concurrency. Invoke for protocol-oriented programming, SwiftUI state management, actors, server-side Swift, UIKit integration, Combine, or Vapor.4license: MIT5metadata:6  author: https://github.com/Jeffallan7  version: "1.1.0"8  domain: language9  triggers: Swift, SwiftUI, iOS development, macOS development, async/await Swift, Combine, UIKit, Vapor10  role: specialist11  scope: implementation12  output-format: code13  related-skills: 14---15 16# Swift Expert17 18## Core Workflow19 201. **Architecture Analysis** - Identify platform targets, dependencies, design patterns212. **Design Protocols** - Create protocol-first APIs with associated types223. **Implement** - Write type-safe code with async/await and value semantics234. **Optimize** - Profile with Instruments, ensure thread safety245. **Test** - Write comprehensive tests with XCTest and async patterns25 26> **Validation checkpoints:** After step 3, run `swift build` to verify compilation. After step 4, run `swift build -warnings-as-errors` to surface actor isolation and Sendable warnings. After step 5, run `swift test` and confirm all async tests pass.27 28## Reference Guide29 30Load detailed guidance based on context:31 32| Topic | Reference | Load When |33|-------|-----------|-----------|34| SwiftUI | `references/swiftui-patterns.md` | Building views, state management, modifiers |35| Concurrency | `references/async-concurrency.md` | async/await, actors, structured concurrency |36| Protocols | `references/protocol-oriented.md` | Protocol design, generics, type erasure |37| Memory | `references/memory-performance.md` | ARC, weak/unowned, performance optimization |38| Testing | `references/testing-patterns.md` | XCTest, async tests, mocking strategies |39 40## Code Patterns41 42### async/await — Correct vs. Incorrect43 44```swift45// ✅ DO: async/await with structured error handling46func fetchUser(id: String) async throws -> User {47    let url = URL(string: "https://api.example.com/users/\(id)")!48    let (data, _) = try await URLSession.shared.data(from: url)49    return try JSONDecoder().decode(User.self, from: data)50}51 52// ❌ DON'T: mixing completion handlers with async context53func fetchUser(id: String) async throws -> User {54    return try await withCheckedThrowingContinuation { continuation in55        // Avoid wrapping existing async APIs this way when a native async version exists56        legacyFetch(id: id) { result in57            continuation.resume(with: result)58        }59    }60}61```62 63### SwiftUI State Management64 65```swift66// ✅ DO: use @Observable (Swift 5.9+) for view models67@Observable68final class CounterViewModel {69    var count = 070    func increment() { count += 1 }71}72 73struct CounterView: View {74    @State private var vm = CounterViewModel()75 76    var body: some View {77        VStack {78            Text("\(vm.count)")79            Button("Increment", action: vm.increment)80        }81    }82}83 84// ❌ DON'T: reach for ObservableObject/Published when @Observable suffices85class LegacyViewModel: ObservableObject {86    @Published var count = 0  // Unnecessary boilerplate in Swift 5.9+87}88```89 90### Protocol-Oriented Architecture91 92```swift93// ✅ DO: define capability protocols with associated types94protocol Repository<Entity> {95    associatedtype Entity: Identifiable96    func fetch(id: Entity.ID) async throws -> Entity97    func save(_ entity: Entity) async throws98}99 100struct UserRepository: Repository {101    typealias Entity = User102    func fetch(id: UUID) async throws -> User { /* … */ }103    func save(_ user: User) async throws { /* … */ }104}105 106// ❌ DON'T: use classes as base types when a protocol fits107class BaseRepository {  // Avoid class inheritance for shared behavior108    func fetch(id: UUID) async throws -> Any { fatalError("Override required") }109}110```111 112### Actor for Thread Safety113 114```swift115// ✅ DO: isolate mutable shared state in an actor116actor ImageCache {117    private var cache: [URL: UIImage] = [:]118 119    func image(for url: URL) -> UIImage? { cache[url] }120    func store(_ image: UIImage, for url: URL) { cache[url] = image }121}122 123// ❌ DON'T: use a class with manual locking124class UnsafeImageCache {125    private var cache: [URL: UIImage] = [:]126    private let lock = NSLock()  // Error-prone; prefer actor isolation127    func image(for url: URL) -> UIImage? {128        lock.lock(); defer { lock.unlock() }129        return cache[url]130    }131}132```133 134## Constraints135 136### MUST DO137- Use type hints and inference appropriately138- Follow Swift API Design Guidelines139- Use `async/await` for asynchronous operations (see pattern above)140- Ensure `Sendable` compliance for concurrency141- Use value types (`struct`/`enum`) by default142- Document APIs with markup comments (`/// …`)143- Use property wrappers for cross-cutting concerns144- Profile with Instruments before optimizing145 146### MUST NOT DO147- Use force unwrapping (`!`) without justification148- Create retain cycles in closures149- Mix synchronous and asynchronous code improperly150- Ignore actor isolation warnings151- Use implicitly unwrapped optionals unnecessarily152- Skip error handling153- Use Objective-C patterns when Swift alternatives exist154- Hardcode platform-specific values155 156## Output Templates157 158When implementing Swift features, provide:1591. Protocol definitions and type aliases1602. Model types (structs/classes with value semantics)1613. View implementations (SwiftUI) or view controllers1624. Tests demonstrating usage1635. Brief explanation of architectural decisions