Swift cheat sheet

enum Currency: String, CaseIterable {
    case gbp, usd
 
    var symbol: String {
        switch self {
        case .gbp: "£"
        case .usd: "$"
        }
    }
}
 
enum MoneyError: Error {
    case currencyMismatch(Currency, Currency)
}
 
struct Money: Comparable, CustomStringConvertible {
    let pence: Int
    let currency: Currency
 
    init(pence: Int, currency: Currency = .gbp) {
        self.pence = pence
        self.currency = currency
    }
 
    init(pounds: Double, currency: Currency = .gbp) {
        self.init(pence: Int((pounds * 100).rounded()), currency: currency)
    }
 
    var description: String {
        let sign = pence < 0 ? "-" : ""
        let whole = abs(pence) / 100
        let fraction = abs(pence) % 100
        let padded = fraction < 10 ? "0\(fraction)" : "\(fraction)"
        return "\(sign)\(currency.symbol)\(whole).\(padded)"
    }
 
    func adding(_ other: Money) throws(MoneyError) -> Money {
        guard other.currency == currency else {
            throw .currencyMismatch(currency, other.currency)
        }
        return Money(pence: pence + other.pence, currency: currency)
    }
 
    static func < (lhs: Money, rhs: Money) -> Bool {
        lhs.pence < rhs.pence
    }
}
 
let price = Money(pence: 1999)
let total = try price.adding(Money(pounds: 5))
print(total)                              // £24.99
print([price, Money(pence: 500)].max()!)  // £19.99
 
do {
    _ = try price.adding(Money(pence: 100, currency: .usd))
} catch .currencyMismatch(let a, let b) {
    print("Cannot add \(a) to \(b)")      // Cannot add gbp to usd
}

struct Settings {
    var theme = "light"
}
 
final class Session {
    var userName: String
    init(userName: String) { self.userName = userName }
}
 
var original = Settings()
var copy = original
copy.theme = "dark"
print(original.theme)          // light: the struct was copied
 
let session = Session(userName: "Ada")
let sameSession = session
sameSession.userName = "Grace"
print(session.userName)        // Grace: both names point at one object
print(session === sameSession) // true

import Foundation
 
struct Repo: Codable {
    let id: Int
    let fullName: String
    let stars: Int
    let description: String?
 
    enum CodingKeys: String, CodingKey {
        case id
        case fullName = "full_name"
        case stars = "stargazers_count"
        case description
    }
}
 
let json = """
{ "id": 1, "full_name": "swiftlang/swift", "stargazers_count": 69000, "description": null }
"""
 
do {
    let repo = try JSONDecoder().decode(Repo.self, from: Data(json.utf8))
    print(repo.fullName, repo.stars)  // swiftlang/swift 69000
 
    let encoder = JSONEncoder()
    encoder.outputFormatting = [.prettyPrinted, .sortedKeys, .withoutEscapingSlashes]
    let data = try encoder.encode(repo)
    print(String(decoding: data, as: UTF8.self))
} catch {
    print("Could not decode: \(error)")
}

struct Profile: Sendable {
    let id: Int
    let name: String
}
 
enum FetchError: Error {
    case notFound(id: Int)
}
 
actor ProfileCache {
    private var profiles: [Int: Profile] = [:]
 
    func profile(for id: Int) -> Profile? { profiles[id] }
    func store(_ profile: Profile) { profiles[profile.id] = profile }
}
 
func fetchProfile(id: Int) async throws -> Profile {
    try await Task.sleep(for: .milliseconds(100)) // stands in for a network call
    guard id > 0 else { throw FetchError.notFound(id: id) }
    return Profile(id: id, name: "User \(id)")
}
 
func loadProfiles(ids: [Int], cache: ProfileCache) async throws -> [Profile] {
    try await withThrowingTaskGroup(of: Profile.self) { group in
        for id in ids {
            group.addTask {
                if let cached = await cache.profile(for: id) { return cached }
                let profile = try await fetchProfile(id: id)
                await cache.store(profile)
                return profile
            }
        }
 
        var profiles: [Profile] = []
        for try await profile in group {
            profiles.append(profile)
        }
        return profiles.sorted { $0.id < $1.id }
    }
}
 
let cache = ProfileCache()
let profiles = try await loadProfiles(ids: [1, 2, 3], cache: cache)
print(profiles.map(\.name)) // ["User 1", "User 2", "User 3"], in about 0.1s, not 0.3s
 
do {
    _ = try await loadProfiles(ids: [1, -1], cache: cache)
} catch FetchError.notFound(let id) {
    print("No profile \(id)")   // No profile -1
}

// swift-tools-version: 6.2
import PackageDescription
 
let package = Package(
    name: "Greeter",
    platforms: [.macOS(.v15)],
    dependencies: [
        .package(url: "https://github.com/apple/swift-argument-parser", from: "1.5.0"),
    ],
    targets: [
        .target(name: "Greeter"),
        .executableTarget(
            name: "greet",
            dependencies: [
                "Greeter",
                .product(name: "ArgumentParser", package: "swift-argument-parser"),
            ]
        ),
        .testTarget(name: "GreeterTests", dependencies: ["Greeter"]),
    ]
)

// Tests/GreeterTests/GreeterTests.swift
import Testing
@testable import Greeter
 
@Test func greetsByName() {
    #expect(greeting(for: "Ada") == "Hello, Ada!")
}
 
@Test(arguments: ["", "Grace"])
func neverEmpty(name: String) {
    #expect(!greeting(for: name).isEmpty)
}