swift-patterns

Swift Patterns

Modern Swift and SwiftUI patterns for iOS development.

iOS Version Selection

| Target | Best For | Stack | |--------|----------|-------| | iOS 26+ | New apps, latest features | SwiftUI + SwiftData + @Observable + Foundation Models | | iOS 17+ | Broad compatibility with modern APIs | SwiftUI + SwiftData + @Observable | | iOS 15+ | Maximum device coverage | SwiftUI + Core Data + ObservableObject |

Reference Files

| Topic | Load | Use When | |-------|------|----------| | Project structure | references/project-structure.md | Setting up or organizing code | | SwiftUI views | references/swiftui-patterns.md | Building UI components | | State management | references/state-management.md | @Observable, ObservableObject, @State | | Data persistence | references/data-persistence.md | SwiftData, Core Data, Keychain | | Networking | references/networking.md | URLSession, API clients | | Concurrency | references/concurrency.md | async/await, actors, tasks | | Navigation | references/navigation.md | NavigationStack, coordinators | | iOS 26 features | references/ios26-features.md | Liquid Glass, Foundation Models |

Quick Start Patterns

Basic SwiftUI View (iOS 17+)

import SwiftUI

struct UserProfileView: View {
    @State private var viewModel = UserProfileViewModel()

    var body: some View {
        Group {
            if viewModel.isLoading {
                ProgressView()
            } else if let user = viewModel.user {
                VStack {
                    Text(user.name)
                        .font(.title)
                    Text(user.email)
                        .foregroundStyle(.secondary)
                }
            } else if let error = viewModel.error {
                ContentUnavailableView(
                    "Error",
                    systemImage: "exclamationmark.triangle",
                    description: Text(error.localizedDescription)
                )
            }
        }
        .task {
            await viewModel.loadUser()
        }
    }
}

Observable ViewModel (iOS 17+)

import Foundation

@Observable
class UserProfileViewModel {
    var user: User?
    var isLoading = false
    var error: Error?

    func loadUser() async {
        isLoading = true
        defer { isLoading = false }

        do {
            user = try await APIClient.shared.fetchCurrentUser()
        } catch {
            self.error = error
        }
    }
}

SwiftData Model (iOS 17+)

import SwiftData

@Model
class User {
    var id: UUID
    var name: String
    var email: String
    var createdAt: Date

    init(id: UUID = UUID(), name: String, email: String) {
        self.id = id
        self.name = name
        self.email = email
        self.createdAt = Date()
    }
}

Async API Call

func fetchUsers() async throws -> [User] {
    let url = URL(string: "https://api.example.com/users")!
    let (data, response) = try await URLSession.shared.data(from: url)

    guard let httpResponse = response as? HTTPURLResponse,
          httpResponse.statusCode == 200 else {
        throw APIError.invalidResponse
    }

    return try JSONDecoder().decode([User].self, from: data)
}

Architecture Patterns

| Pattern | Best For | Complexity | |---------|----------|------------| | MVVM | Most apps | Medium | | TCA | Large teams, complex state | High | | Coordinator | Complex navigation | Medium |

Essential Packages

| Package | Purpose | |---------|---------| | SwiftData | Persistence (iOS 17+) | | SwiftUI | UI framework | | Foundation | Networking, dates, etc. | | Swift Testing | Modern testing | | KeychainAccess | Secure storage |

Swift 6.2 Key Features

1. Approachable Concurrency - Main thread by default
2. @concurrent - Explicit background execution
3. Typed throws - Better error handling
4. @Animatable macro - Simplified animations

Code Quality Rules

1. @Observable over ObservableObject - For iOS 17+
2. Structured concurrency - Use async/await, not callbacks
3. SwiftData over Core Data - For iOS 17+ new projects
4. Swift Testing over XCTest - For new test code
5. SPM over CocoaPods - For dependency management
6. Value types - Prefer structs over classes when possible