Swift 5.9 Cheatsheet: Optionals, Protocols, Generics and Concurrency

# macOS — Swift ships with the Xcode command-line tools
xcode-select --install

# Linux — install the official tarball from swift.org/install
# (or use swiftly, the toolchain manager)
curl -O https://download.swift.org/swift-5.10-release/ubuntu2204/...
tar xzf swift-*.tar.gz

# New SwiftPM project
swift package init --type executable --name MyApp
swift run                              # build + run
swift build -c release                 # optimized binary in .build/release/

# Daily commands
swift test                             # XCTest
swift package update                   # bump deps
swift-format --in-place --recursive Sources/

# Open the same package in Xcode
xed .                                  # opens current dir in Xcode

// Optionals — every wrapped value must be unwrapped before use

let name: String? = "Ada"
let email: String? = nil

// 1 · if-let — bind only when non-nil
if let name = name {
    print("name = \(name)")
}

// 2 · guard-let — early exit, keep happy path flat
func greet(_ name: String?) {
    guard let name, !name.isEmpty else {
        print("anon"); return
    }
    print("hi \(name)")        // unwrapped from here on
}

// 3 · nil-coalescing — default when missing
let display = email ?? "no email"

// 4 · optional chaining — short-circuits on nil
let upper = email?.uppercased()      // String?

// 5 · throwing variant — bridges Result/throws
func parsePort(_ s: String?) throws -> Int {
    guard let s, let n = Int(s) else {
        throw URLError(.badURL)
    }
    return n
}

print(display)
greet(nil)
greet("Grace")
print(try parsePort("8080"))

// Protocol with associated type + default implementation
protocol Repository {
    associatedtype Item: Identifiable
    func all() async throws -> [Item]
    func find(_ id: Item.ID) async throws -> Item?
}

extension Repository {
    func count() async throws -> Int {            // default impl
        try await all().count
    }
}

// Value type that conforms
struct User: Identifiable, Codable, Equatable {
    let id: String
    var name: String
}

actor InMemoryUsers: Repository {                 // actor — serial access
    private var store: [String: User] = [:]

    func upsert(_ u: User) { store[u.id] = u }
    func all() -> [User] { Array(store.values) }
    func find(_ id: String) -> User? { store[id] }
}

// Generic constraint via where-clause
func print(all repo: some Repository) async throws {
    let xs = try await repo.all()
    print("loaded \(xs.count)")
}

// Package.swift dependencies:
// .package(url: "https://github.com/apple/swift-async-algorithms.git", from: "1.0.0"),

import Foundation

struct Repo: Decodable {
    let name: String
    let stargazersCount: Int
    enum CodingKeys: String, CodingKey {
        case name, stargazersCount = "stargazers_count"
    }
}

func fetchRepos(owner: String) async throws -> [Repo] {
    var req = URLRequest(url: URL(string: "https://api.github.com/users/\(owner)/repos?per_page=5")!)
    req.setValue("devshelf", forHTTPHeaderField: "User-Agent")

    let (data, resp) = try await URLSession.shared.data(for: req)
    guard let http = resp as? HTTPURLResponse, (200..<300).contains(http.statusCode) else {
        throw URLError(.badServerResponse)
    }
    return try JSONDecoder().decode([Repo].self, from: data)
}

@main
struct Main {
    static func main() async {
        let owners = ["apple", "vapor", "pointfreeco"]

        // Concurrent fan-out via async let
        await withTaskGroup(of: (String, Result<[Repo], Error>).self) { group in
            for owner in owners {
                group.addTask {
                    do    { return (owner, .success(try await fetchRepos(owner: owner))) }
                    catch { return (owner, .failure(error)) }
                }
            }
            for await (owner, result) in group {
                switch result {
                case .success(let repos):
                    for r in repos { print("\(owner)/\(r.name) ★\(r.stargazersCount)") }
                case .failure(let err):
                    print("\(owner): \(err.localizedDescription)")
                }
            }
        }
    }
}