Swift Fundamentals Skill

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)")

Usage

Skill("swift-fundamentals")

Related Skills

• swift-spm - Package management
• swift-testing - Testing fundamentals code