Swift Fundamentals Skill Skill

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

Agent Skills: Swift Fundamentals Skill

Skill Files