Comprehensive knowledge base for Swift language fundamentals, type system, and idiomatic patterns.
Prerequisites
Xcode 15+ installed
Swift 5.9+ toolchain
Basic programming knowledge
Parameters
parameters:
swift_version:
type: string
default: "5.9"
enum: ["5.5", "5.6", "5.7", "5.8", "5.9", "5.10", "6.0"]
description: Target Swift version for compatibility
strict_concurrency:
type: boolean
default: true
description: Enable strict concurrency checking
coding_style:
type: string
enum: [apple, google, raywenderlich]
default: apple
Topics Covered
Type System
Topic
Description
Swift Version
Value Types
struct, enum, copy semantics
5.0+
Reference Types
class, ARC, identity
5.0+
Generics
Type parameters, constraints
5.0+
Opaque Types
some keyword, type erasure
5.1+
Existentials
any keyword, protocol types
5.6+
Optionals
Pattern
Use Case
Example
if let
Conditional unwrap
if let x = optional { }
guard let
Early exit
guard let x = optional else { return }
??
Default value
optional ?? defaultValue
?.
Optional chaining
object?.property?.method()
!
Force unwrap (avoid)
Only when provably safe
Protocols
Feature
Description
Protocol Composition
Codable & Sendable
Associated Types
Generic protocols with associatedtype
Conditional Conformance
extension Array: Equatable where Element: Equatable
Protocol Extensions
Default implementations
Error Handling
Pattern
Syntax
Use Case
Throwing
func x() throws
Recoverable errors
Result
Result<Success, Failure>
Async contexts
Optional
try?
Silent failure
Force
try!
Guaranteed success
Code Examples
Protocol-Oriented Design
protocol Identifiable {
associatedtype ID: Hashable
var id: ID { get }
}
protocol Persistable: Identifiable {
func save() async throws
static func load(id: ID) async throws -> Self?
}
extension Persistable where Self: Codable {
func save() async throws {
let data = try JSONEncoder().encode(self)
try await Storage.shared.write(data, forKey: "\(Self.self)-\(id)")
}
}
Safe Optional Handling
struct UserProfile {
let name: String
let email: String?
let avatarURL: URL?
}
func displayUser(_ user: UserProfile?) {
guard let user else {
showPlaceholder()
return
}
nameLabel.text = user.name
emailLabel.text = user.email ?? "No email provided"
if let avatarURL = user.avatarURL {
loadImage(from: avatarURL)
}
}
Modern Error Handling
enum ValidationError: LocalizedError {
case emptyField(String)
case invalidFormat(String, expected: String)
case outOfRange(String, min: Int, max: Int)
var errorDescription: String? {
switch self {
case .emptyField(let field):
return "\(field) cannot be empty"
case .invalidFormat(let field, let expected):
return "\(field) must be in \(expected) format"
case .outOfRange(let field, let min, let max):
return "\(field) must be between \(min) and \(max)"
}
}
}
func validate(username: String) throws -> String {
guard !username.isEmpty else {
throw ValidationError.emptyField("Username")
}
guard username.count >= 3, username.count <= 20 else {
throw ValidationError.outOfRange("Username", min: 3, max: 20)
}
return username
}
Troubleshooting
Common Issues
Issue
Cause
Solution
"Cannot convert value of type"
Type mismatch
Check expected type, add explicit cast
"Value of optional type not unwrapped"
Missing unwrap
Use if let, guard let, or ??
"Protocol can only be used as generic constraint"
PAT in variable
Use any or type erasure
"Closure captures 'self' strongly"
Retain cycle
Add [weak self] capture
Debug Commands
# Check Swift version
swift --version
# Compile with strict concurrency
swift build -Xswiftc -strict-concurrency=complete
# Dump AST for debugging
swiftc -dump-ast file.swift
Validation Rules
validation:
- rule: no_force_unwrap
severity: warning
message: Avoid force unwrapping optionals
- rule: no_implicitly_unwrapped
severity: warning
message: Avoid implicitly unwrapped optionals except for IBOutlets
- rule: prefer_guard
severity: info
message: Prefer guard for early exit over nested if-let
Retry Logic
func withRetry<T>(
maxAttempts: Int = 3,
delay: Duration = .seconds(1),
operation: () async throws -> T
) async throws -> T {
var lastError: Error?
for attempt in 1...maxAttempts {
do {
return try await operation()
} catch {
lastError = error
if attempt < maxAttempts {
try await Task.sleep(for: delay * Double(attempt))
}
}
}
throw lastError!
}
Observability
import OSLog
extension Logger {
static let swift = Logger(subsystem: "com.app", category: "swift")
}
// Usage
Logger.swift.debug("Parsing user: \(userId)")
Logger.swift.error("Failed to decode: \(error.localizedDescription)")