Swift Cheat Sheet

print("Hello, world!")

@main struct App { static func main() async throws { print("running") } }

// line comment /* block comment, which can nest /* like this */ */ /// Documentation comment, shown in Quick Help /// - Parameter name: who to greet /// - Returns: the greeting

let maximum = 100 // cannot change var counter = 0 // can change counter += 1

let name: String = "Ada" var scores: [Int] = [] let ratio: Double = 0.75

let result: Int if condition { result = 1 } else { result = 2 }

let x = 0, y = 0, z = 0 var red, green, blue: Double

enum Config { static let apiVersion = "v2" static let timeout: TimeInterval = 30 } Config.apiVersion

let name = "Ada" let age = 36 print("\(name) is \(age)") print("next year: \(age + 1)")

print("a", "b", "c", separator: " | ") print("no newline", terminator: "")

dump(user) // full structure debugPrint(user) // uses debugDescription

let price = 1234.5 price.formatted(.currency(code: "EUR")) // "€1,234.50" (0.87).formatted(.percent) // "87%" String(format: "%.2f", price) // "1234.50"

let dec = 1_000_000 let hex = 0xFF let oct = 0o77 let bin = 0b1010_1010 let sci = 1.25e3 // 1250.0

let count = 3 let ratio = 0.75 let total = Double(count) * ratio // no implicit widening let rounded = Int(total) // truncates toward zero

let n = Int("42") // Optional(42) let bad = Int("4x2") // nil let safe = Int(exactly: 3.0) // Optional(3) let lossy = Int(exactly: 3.5) // nil

(2.7).rounded() // 3.0 (2.7).rounded(.down) // 2.0 abs(-4) // 4 max(1, 9), min(1, 9) (2.0).squareRoot() Int.random(in: 1...6)

Int.max &+ 1 // wraps, no trap let (v, overflowed) = Int.max.addingReportingOverflow(1) Int8(clamping: 500) // 127

0.1 + 0.2 == 0.3 // false // compare against a tolerance scaled to the magnitude func isClose(_ a: Double, _ b: Double, tolerance: Double = 1e-9) -> Bool { abs(a - b) <= tolerance * max(abs(a), abs(b), 1) } // money belongs in Decimal, never in Double let amount = Decimal(string: "19.99")!

let point = (x: 3, y: 7) print(point.x, point.1) let (status, message) = (404, "Not Found")

1...5 // 1,2,3,4,5 1..<5 // 1,2,3,4 let letters = "a"..."f" array[2...] // from index 2 to the end array[..<3] // up to but not including 3

if value is String { } let text = value as? String // Optional let forced = value as! String // traps if wrong let any: Any = 42 // upcast, always safe

typealias JSON = [String: Any] typealias Completion = (Result<Data, Error>) -> Void

var middleName: String? // starts as nil var age: Int? = 36 age = nil // allowed, it is Optional<Int>

if let name = middleName { print("middle name is \(name)") } else { print("no middle name") }

if let middleName { print(middleName) // Swift 5.7 and later }

func greet(_ name: String?) { guard let name else { print("nobody to greet") return } // name is a non optional String from here on print("Hello, \(name)") }

guard let url = URL(string: raw), let host = url.host, !host.isEmpty else { return }

let display = middleName ?? "none" let port = config.port ?? 8080 let first = list.first ?? "empty"

let count = user?.profile?.followers?.count // count is Int?, nil if any link is nil user?.profile?.refresh() // simply does nothing if nil

let length = middleName?.count // Int? let upper = middleName.map { $0.uppercased() } // String? let parsed = raw.flatMap { Int($0) } // Int?, no double optional

let raw = ["1", "two", "3"] let numbers = raw.compactMap { Int($0) } // [1, 3]

switch age { case .some(let value) where value >= 18: print("adult") case .some(let value): print("minor, \(value)") case .none: print("unknown") }

user.nickname = incoming ?? user.nickname if let incoming { user.nickname = incoming }

// avoid let name = middleName! // if it truly cannot fail, say why let url = URL(string: "https://example.com")! // literal, verified // better still, fail loudly with a reason guard let url else { preconditionFailure("base URL must be valid") }

@IBOutlet var label: UILabel! var delegate: Handler! // set immediately after init

let greeting = "Hello" var empty = "" let line = String(repeating: "-", count: 20) let fromChar = String(Character("A"))

let query = """ SELECT * FROM users WHERE active = 1 """

let path = #"C:\Users\new\table"# let regex = #"\d{3}-\d{4}"# let mixed = #"total is \#(amount)"# // interpolate inside raw

var s = "Hello" s += ", world" s.append("!") let csv = ["a", "b", "c"].joined(separator: ",")

"\n \t \\ \" \' \0" "\u{1F600}" // emoji by scalar

text.count // grapheme clusters, not bytes text.isEmpty "cafe\u{301}".count // 4, the accent combines

text.contains("swift") text.hasPrefix("https://") text.hasSuffix(".json") text.lowercased(), text.uppercased() text.capitalized

import Foundation let clean = raw.trimmingCharacters(in: .whitespacesAndNewlines)

let parts = "a,b,c".split(separator: ",") // [Substring] let words = sentence.split(whereSeparator: \.isWhitespace) let fixed = text.replacingOccurrences(of: "-", with: "_")

for ch in "abc" { print(ch) } for (i, ch) in text.enumerated() { } Array(text) // [Character] text.unicodeScalars.map(\.value) Array(text.utf8) // [UInt8]

let first = text[text.startIndex] let idx = text.index(text.startIndex, offsetBy: 3) let slice = text[idx...] // Substring let sub = String(text.prefix(5)) let tail = String(text.suffix(3))

if let r = text.range(of: "swift") { let before = text[..<r.lowerBound] let match = text[r] }

text.prefix(10) text.dropFirst() text.dropLast(3) text.prefix(while: { $0.isLetter })

let re = /(\d{4})-(\d{2})-(\d{2})/ if let m = "due 2026-08-20".firstMatch(of: re) { print(m.1, m.2, m.3) } let all = text.matches(of: /\w+@\w+\.\w+/) let cleaned = text.replacing(/\s+/, with: " ")

var names = ["Ada", "Grace"] var empty: [Int] = [] var zeros = [Int](repeating: 0, count: 5) var reserved = [Int](); reserved.reserveCapacity(100)

names.append("Alan") names += ["Barbara"] names.insert("Edsger", at: 0) names.remove(at: 1) names.removeFirst(); names.removeLast() names.removeAll()

names[0] // traps if out of range names.first, names.last // Optional names.isEmpty, names.count names.indices names.contains("Ada")

extension Collection { subscript(safe index: Index) -> Element? { indices.contains(index) ? self[index] : nil } } names[safe: 99] // nil instead of a crash

names.sort() let sorted = names.sorted() let byLength = names.sorted { $0.count < $1.count } users.sort(using: KeyPathComparator(\.age)) names.reverse() names.shuffle()

let lengths = names.map(\.count) let long = names.filter { $0.count > 4 } let total = numbers.reduce(0, +) let joined = names.reduce("") { $0 + $1 }

let ints = ["1", "x", "3"].compactMap { Int($0) } // [1, 3] let flat = [[1, 2], [3]].flatMap { $0 } // [1, 2, 3]

names.first { $0.hasPrefix("A") } names.firstIndex(of: "Ada") names.allSatisfy { !$0.isEmpty } names.contains { $0.count > 6 } numbers.min(), numbers.max()

names.prefix(2) names.dropFirst(2) zip(names, ages) // pairs, stops at the shorter names.enumerated() // (offset, element) Array(names.reversed())

let byInitial = Dictionary(grouping: names) { $0.first! } // ["A": ["Ada", "Alan"], "G": ["Grace"]]

let firstBig = numbers.lazy .map { $0 * $0 } .first { $0 > 1_000 }

var ages = ["Ada": 36, "Grace": 45] var empty: [String: Int] = [:] ages["Ada"] // Optional(36) ages["Nobody", default: 0] // 0, no optional

ages["Alan"] = 41 ages["Alan"] = nil // removes the key ages.removeValue(forKey: "Ada") // returns the old value ages.updateValue(37, forKey: "Ada")

var counts: [Character: Int] = [:] for ch in text { counts[ch, default: 0] += 1 }

for (name, age) in ages { } ages.keys.sorted() ages.values.reduce(0, +) ages.mapValues { $0 + 1 } ages.filter { $0.value > 40 }

Dictionary(uniqueKeysWithValues: zip(names, ages)) Dictionary(pairs, uniquingKeysWith: { first, _ in first })

var tags: Set<String> = ["swift", "ios"] tags.insert("xcode") // (inserted: Bool, memberAfterInsert) tags.contains("swift") // O(1) tags.remove("ios")

a.union(b) a.intersection(b) a.subtracting(b) a.symmetricDifference(b) a.isSubset(of: b) a.isDisjoint(with: b)

var seen = Set<String>() let unique = names.filter { seen.insert($0).inserted }

if score >= 90 { grade = "A" } else if score >= 80 { grade = "B" } else { grade = "C" }

let label = isActive ? "on" : "off"

let grade = if score >= 90 { "A" } else if score >= 80 { "B" } else { "C" } let color = switch state { case .idle: "gray" case .active: "green" case .failed: "red" }

func send(_ message: String) throws { guard !message.isEmpty else { throw SendError.empty } guard isConnected else { throw SendError.offline } // happy path, unindented }

switch statusCode { case 200: print("ok") case 400..<500: print("client error") case 500...: print("server error") default: print("unknown") }

switch ch { case "a", "e", "i", "o", "u": print("vowel") case "a"..."z": print("consonant") default: print("other") }

switch point { case (0, 0): print("origin") case (let x, 0): print("on x axis at \(x)") case (let x, let y) where x == y: print("diagonal") case (-2...2, -2...2): print("near origin") default: print("elsewhere") }

switch value { case let n as Int: print("int \(n)") case let s as String: print("string \(s)") case is [Any]: print("some array") default: break }

switch result { case .success(let data) where data.isEmpty: print("empty") case .success(let data): print("\(data.count) bytes") case .failure(let error): print(error) }

if case .success(let data) = result { } for case let .success(data) in results { } if 1...9 ~= digit { }

for i in 1...5 { } for i in stride(from: 0, to: 10, by: 2) { } for name in names { } for (key, value) in dict { } for _ in 1...3 { } // ignore the value

for (index, name) in names.enumerated() { print("\(index): \(name)") }

for name in names where name.count > 3 { print(name) }

while !queue.isEmpty { process(queue.removeFirst()) } repeat { attempt += 1 } while attempt < 3

outer: for row in grid { for cell in row { if cell == target { break outer } } }

func read() throws -> Data { let handle = try FileHandle(forReadingFrom: url) defer { try? handle.close() } return try handle.readToEnd() ?? Data() }

func add(_ a: Int, _ b: Int) -> Int { a + b // single expression, return is implicit } func greet(name: String) -> String { return "Hello, \(name)" }

func move(from start: Point, to end: Point) { } move(from: a, to: b) func log(_ message: String) { } // _ removes the label log("no label needed")

func connect(host: String, port: Int = 443, retries: Int = 3) { } connect(host: "example.com") func sum(_ numbers: Int...) -> Int { numbers.reduce(0, +) } sum(1, 2, 3, 4)

func double(_ value: inout Int) { value *= 2 } var score = 21 double(&score) // score is 42

func bounds(of values: [Int]) -> (min: Int, max: Int)? { guard let lo = values.min(), let hi = values.max() else { return nil } return (lo, hi) } if let b = bounds(of: scores) { print(b.min, b.max) }

func crash(_ reason: String) -> Never { fatalError(reason) }

names.sorted(by: { (a: String, b: String) -> Bool in return a < b }) names.sorted(by: { a, b in a < b }) // types inferred names.sorted(by: { $0 < $1 }) // positional names names.sorted { $0 < $1 } // trailing closure names.sorted(by: <) // operator as function

let square: (Int) -> Int = { $0 * $0 } var onFinish: (() -> Void)? onFinish?()

UIView.animate(withDuration: 0.3) { view.alpha = 0 } completion: { _ in view.removeFromSuperview() }

func fetch(_ completion: @escaping (Data) -> Void) { queue.async { completion(data) } }

// strong by default, this is the retain cycle button.onTap = { self.reload() } // break it button.onTap = { [weak self] in self?.reload() } // capture a snapshot by value let handler = { [count] in print(count) }

load { [weak self] data in guard let self else { return } self.items = data self.reload() }

func assert(_ condition: Bool, _ message: @autoclosure () -> String) { if !condition { print(message()) } } assert(ok, "expensive \(buildReport())") // only built on failure

let names = users.map(\.name) let adults = users.filter(\.isAdult) users.sorted(using: KeyPathComparator(\.age))

let path = \User.profile.city let city = user[keyPath: path] let writable = \User.nickname user[keyPath: writable] = "Ada"

let printer = print // (Any...) -> Void names.forEach(printer) let trim = String.trimmingCharacters(in:)

struct User { let id: UUID var name: String var age: Int = 0 } let u = User(id: UUID(), name: "Ada", age: 36) let v = User(id: UUID(), name: "Grace") // age defaults

var a = User(id: UUID(), name: "Ada") var b = a b.name = "Grace" // a.name is still "Ada"

struct Counter { private(set) var value = 0 mutating func increment() { value += 1 } mutating func reset() { self = Counter() } }

extension User { init(name: String) { self.init(id: UUID(), name: name, age: 0) } }

class Session { let id: String var isActive = false init(id: String) { self.id = id } deinit { print("session \(id) released") } }

let s1 = Session(id: "a") let s2 = s1 s2.isActive = true // s1.isActive is now true as well, and s1 is a let s1 === s2 // true, same instance

class Animal { func speak() -> String { "..." } } class Dog: Animal { override func speak() -> String { "Woof" } } final class Puppy: Dog { } // final blocks further subclassing

class Vehicle { var wheels: Int init(wheels: Int) { self.wheels = wheels } convenience init() { self.init(wheels: 4) } } class Truck: Vehicle { var payload: Double init(payload: Double) { self.payload = payload // own properties first super.init(wheels: 6) // then super } }

struct Port { let number: UInt16 init?(_ value: Int) { guard (1...65535).contains(value) else { return nil } number = UInt16(value) } } Port(0) // nil

let big = Array(0..<1_000_000) var copy = big // no allocation yet, storage is shared copy.append(1) // now, and only now, it is duplicated

struct Buffer { private var storage: Storage mutating func write(_ byte: UInt8) { if !isKnownUniquelyReferenced(&storage) { storage = storage.copy() } storage.append(byte) } }

enum Direction { case north, south, east, west } let heading: Direction = .north if heading == .north { }

enum Status: Int { case ok = 200, notFound = 404, error = 500 } Status.notFound.rawValue // 404 Status(rawValue: 200) // Optional(.ok)

enum Weekday: String, CaseIterable { case mon, tue, wed, thu, fri } Weekday.allCases.count // 5 Weekday.allCases.map(\.rawValue)

enum Direction: CaseIterable { case north, south, east, west var opposite: Direction { switch self { case .north: .south case .south: .north case .east: .west case .west: .east } } func degrees() -> Double { ... } }

enum Loading { case idle case inFlight(progress: Double) case loaded(items: [Item]) case failed(Error) }

switch state { case .idle: showPlaceholder() case .inFlight(let progress): showBar(progress) case .loaded(let items): show(items) case .failed(let error): showError(error) }

extension Loading { var items: [Item] { if case .loaded(let items) = self { items } else { [] } } var isFailed: Bool { if case .failed = self { true } else { false } } }

indirect enum Expr { case value(Int) case add(Expr, Expr) case multiply(Expr, Expr) } func eval(_ e: Expr) -> Int { switch e { case .value(let n): n case .add(let a, let b): eval(a) + eval(b) case .multiply(let a, let b): eval(a) * eval(b) } }

enum Result<Success, Failure: Error> { case success(Success) case failure(Failure) }

struct Permissions: OptionSet { let rawValue: Int static let read = Permissions(rawValue: 1 << 0) static let write = Permissions(rawValue: 1 << 1) static let execute = Permissions(rawValue: 1 << 2) static let all: Permissions = [.read, .write, .execute] } var p: Permissions = [.read, .write] p.contains(.write) // true p.insert(.execute) p.remove(.read)

struct CountryCode: RawRepresentable, Hashable { let rawValue: String init?(rawValue: String) { guard rawValue.count == 2 else { return nil } self.rawValue = rawValue.uppercased() } }

enum Status: String, Codable { case active, paused, unknown init(from decoder: Decoder) throws { let raw = try decoder.singleValueContainer().decode(String.self) self = Status(rawValue: raw) ?? .unknown } }

protocol Identifiable { var id: String { get } func refresh() throws } struct User: Identifiable { let id: String func refresh() throws { } }

struct User { let id: String } extension User: Identifiable { func refresh() throws { } }

struct Article: Identifiable, Codable, Hashable, Sendable { } func render(_ item: some Identifiable & Codable) { }

protocol Reloadable: Identifiable { func reload() async } protocol Delegate: AnyObject { // classes only, so it can be weak func didFinish() }

protocol Greeter { var name: String { get } func greet() -> String } extension Greeter { func greet() -> String { "Hello, \(name)" } } struct English: Greeter { let name: String } // greet comes free

extension Collection where Element: Numeric { var total: Element { reduce(.zero, +) } } [1, 2, 3].total // 6

protocol P { } extension P { func hello() { print("protocol") } } struct S: P { func hello() { print("struct") } } let s: P = S() s.hello() // "protocol", because hello is not a requirement

func makeGreeter() -> some Greeter { English(name: "Ada") } func render(_ item: some Identifiable) { } // shorthand generic

var greeters: [any Greeter] = [English(name: "Ada"), French(name: "Ana")] func handle(_ item: any Identifiable) { }

protocol Repository { associatedtype Item func fetch(id: String) async throws -> Item } struct UserRepo: Repository { func fetch(id: String) async throws -> User { ... } }

protocol Repository<Item> { associatedtype Item func fetch(id: String) async throws -> Item } func load(from repo: any Repository<User>) async { }

protocol Copyable { func copy() -> Self } extension Equatable { func isSame(as other: Self) -> Bool { self == other } }

struct Vector { var x, y: Double static func + (a: Vector, b: Vector) -> Vector { Vector(x: a.x + b.x, y: a.y + b.y) } static func += (a: inout Vector, b: Vector) { a = a + b } static prefix func - (v: Vector) -> Vector { Vector(x: -v.x, y: -v.y) } }

infix operator ** : MultiplicationPrecedence func ** (base: Double, power: Double) -> Double { pow(base, power) }

struct Version: Comparable { let major, minor, patch: Int static func < (a: Version, b: Version) -> Bool { (a.major, a.minor, a.patch) < (b.major, b.minor, b.patch) } }

func swapValues<T>(_ a: inout T, _ b: inout T) { (a, b) = (b, a) }

func largest<T: Comparable>(_ items: [T]) -> T? { items.max() } func describe<T: CustomStringConvertible & Hashable>(_ v: T) { }

struct Stack<Element> { private var items: [Element] = [] mutating func push(_ item: Element) { items.append(item) } mutating func pop() -> Element? { items.popLast() } var isEmpty: Bool { items.isEmpty } } var s = Stack<Int>() var inferred = Stack<String>()

func merge<C1: Collection, C2: Collection>(_ a: C1, _ b: C2) -> [C1.Element] where C1.Element == C2.Element, C1.Element: Hashable { Array(Set(a).union(b)) }

func evens(_ xs: [Int]) -> some Sequence<Int> { xs.lazy.filter { $0 % 2 == 0 } }

func describeAll<each T: CustomStringConvertible>( _ values: repeat each T ) -> [String] { var out: [String] = [] repeat out.append((each values).description) return out } describeAll(1, "two", 3.0) // ["1", "two", "3.0"]

struct Tagged<Tag, Value> { let value: Value } enum UserIDTag { } enum OrderIDTag { } typealias UserID = Tagged<UserIDTag, String> typealias OrderID = Tagged<OrderIDTag, String> // now a UserID cannot be passed where an OrderID is expected

struct AnyRepository<Item>: Repository { private let _fetch: (String) async throws -> Item init<R: Repository>(_ repo: R) where R.Item == Item { _fetch = repo.fetch } func fetch(id: String) async throws -> Item { try await _fetch(id) } }

func fetch<T: Decodable>(_ type: T.Type, from url: URL) async throws -> T { let (data, _) = try await URLSession.shared.data(from: url) return try JSONDecoder().decode(T.self, from: data) } let user = try await fetch(User.self, from: url)

extension Array where Element == String { var longest: String? { self.max(by: { $0.count < $1.count }) } } extension Optional where Wrapped: Collection { var isNilOrEmpty: Bool { self?.isEmpty ?? true } }

final class Cache<Key: Hashable, Value> { private var storage: [Key: Value] = [:] subscript(key: Key) -> Value? { get { storage[key] } set { storage[key] = newValue } } }

struct Pair<T> { let a: T; let b: T } extension Pair: Equatable where T: Equatable { } extension Pair: Codable where T: Codable { }

enum LoadError: Error { case notFound(path: String) case malformed case tooLarge(bytes: Int) }

func load(_ path: String) throws -> Data { guard exists(path) else { throw LoadError.notFound(path: path) } return try read(path) } do { let data = try load("config.json") } catch LoadError.notFound(let path) { print("missing \(path)") } catch { print("other failure: \(error)") }

let data = try load(path) // propagate, needs throws or do let maybe = try? load(path) // Optional, error discarded let forced = try! load(path) // crash if it throws

do { try load(path) } catch LoadError.notFound, LoadError.malformed { useDefaults() } catch let error as LoadError { report(error) } catch { throw error }

func process() throws { let lock = acquire() defer { release(lock) } try risky() // lock is released either way }

let outcome = Result { try load(path) } switch outcome { case .success(let data): use(data) case .failure(let error): report(error) } let value = try outcome.get()

extension LoadError: LocalizedError { var errorDescription: String? { switch self { case .notFound(let path): "No file at \(path)" case .malformed: "The file could not be parsed" case .tooLarge(let n): "File is too large (\(n) bytes)" } } }

func mapAll<T, U>(_ items: [T], _ f: (T) throws -> U) rethrows -> [U] { try items.map(f) } // only throws when the closure you passed throws

func load(_ path: String) throws(LoadError) -> Data { ... } do { try load(path) } catch { // error is LoadError, no casting needed }

assert(count > 0, "count must be positive") // debug only precondition(index < size, "index out of range") // release too fatalError("unreachable")

struct Rect { var width = 0.0 var height = 0.0 var area: Double { width * height } // read only var diagonal: Double { get { (width * width + height * height).squareRoot() } set { width = newValue / 2; height = newValue / 2 } } }

var progress: Double = 0 { willSet { print("about to become \(newValue)") } didSet { if progress != oldValue { redraw() } } }

class Importer { lazy var parser = ExpensiveParser() // built on first access }

struct Theme { static let shared = Theme() static var count = 0 static func reset() { count = 0 } } class Base { class func describe() -> String { "base" } // overridable }

struct Matrix { private var grid: [Double] let columns: Int subscript(row: Int, col: Int) -> Double { get { grid[row * columns + col] } set { grid[row * columns + col] = newValue } } }

public struct Cart { public private(set) var items: [Item] = [] public mutating func add(_ item: Item) { items.append(item) } }

@propertyWrapper struct Clamped { private var value: Int private let range: ClosedRange<Int> init(wrappedValue: Int, _ range: ClosedRange<Int>) { self.range = range self.value = min(max(wrappedValue, range.lowerBound), range.upperBound) } var wrappedValue: Int { get { value } set { value = min(max(newValue, range.lowerBound), range.upperBound) } } } struct Player { @Clamped(0...100) var health = 100 }

@State @Binding @Environment // SwiftUI @Published // Combine @AppStorage @SceneStorage // persisted UI state @MainActor // an attribute, not a wrapper

let shared = Service() // created on first use, exactly once enum Env { static let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? "" }

final class Analytics { static let shared = Analytics() private init() { } // stops anyone constructing a second one }

// error under strict concurrency var counter = 0 // fix: isolate it @MainActor var counter = 0 // or actor Counter { private var value = 0 }

extension URL { static var api: URL { URL(string: "https://api.example.com")! } } // used as .api at any call site expecting a URL

class Parent { var child: Child? } class Child { var parent: Parent? } // leak // fix: one direction must be weak class Child { weak var parent: Parent? }

class ViewModel { var onUpdate: (() -> Void)? func setup() { onUpdate = { self.reload() } // self holds closure holds self } } // fix onUpdate = { [weak self] in self?.reload() }

protocol LoaderDelegate: AnyObject { func loaderDidFinish(_ loader: Loader) } class Loader { weak var delegate: LoaderDelegate? }

class Customer { var card: Card? } class Card { unowned let owner: Customer // a card never outlives its owner init(owner: Customer) { self.owner = owner } }

deinit { print("\(Self.self) deinit") } // should print when expected // Xcode: Debug Memory Graph, or Instruments Leaks // swift build -Xswiftc -warn-long-expression-type-checking

struct Node { var value: Int var children: [Node] // fine, no ARC, no cycle possible }

var total = 0 func addTo(_ value: inout Int) { value += total } addTo(&total) // error: overlapping access to total

// stored, so it can outlive the call: weak self.onDone = { [weak self] in self?.finish() } // non escaping, finishes before the call returns: no capture list items.map { self.transform($0) } // Task inside a class that may be cancelled: weak task = Task { [weak self] in await self?.load() }

var count = 0 let printer = { [count] in print(count) } // captures 0 count = 5 printer() // still prints 0

button.action = { [weak viewModel, unowned router] in viewModel?.submit() router.dismiss() }

Task { [weak self] in guard let self else { return } let data = await self.load() self.apply(data) // still alive here, self is strong now }

func loadUser(id: String) async throws -> User { let (data, _) = try await URLSession.shared.data(from: url) return try JSONDecoder().decode(User.self, from: data) } let user = try await loadUser(id: "42")

Task { let user = try await loadUser(id: "42") await MainActor.run { self.user = user } } // SwiftUI .task { await load() }

async let profile = loadProfile() async let posts = loadPosts() let (p, ps) = try await (profile, posts) // both run at once

let images = try await withThrowingTaskGroup(of: Image.self) { group in for url in urls { group.addTask { try await download(url) } } var result: [Image] = [] for try await image in group { result.append(image) } return result }

let task = Task { try await longJob() } task.cancel() // inside the job try Task.checkCancellation() if Task.isCancelled { return } try await Task.sleep(for: .seconds(1)) // throws on cancel

actor Counter { private var value = 0 func increment() { value += 1 } func current() -> Int { value } } let counter = Counter() await counter.increment() let n = await counter.current()

@MainActor final class ViewModel: ObservableObject { @Published var items: [Item] = [] func load() async { let fetched = await service.fetch() // hops off and back items = fetched // already on the main actor } } @MainActor func updateLabel() { }

struct Payload: Sendable { let id: String } // value types: automatic final class Config: Sendable { let name: String // immutable, so it is safe init(name: String) { self.name = name } } @unchecked Sendable // "trust me", you handle the locking

actor Store { let id: String nonisolated var describedBy: String { "Store(\(id))" } }

for try await line in url.lines { print(line) } for await note in NotificationCenter.default.notifications(named: .didUpdate) { }

let stream = AsyncStream<Int> { continuation in let timer = startTimer { continuation.yield($0) } continuation.onTermination = { _ in timer.stop() } } for await tick in stream { print(tick) }

func load() async throws -> Data { try await withCheckedThrowingContinuation { continuation in legacyLoad { result in continuation.resume(with: result) } } }

Task.detached(priority: .background) { await reindex() } await Task.yield() try await Task.sleep(for: .milliseconds(250))

import Combine var bag = Set<AnyCancellable>() searchField.textPublisher .debounce(for: .milliseconds(300), scheduler: RunLoop.main) .removeDuplicates() .filter { $0.count > 2 } .sink { [weak self] term in self?.search(term) } .store(in: &bag)

Just(5) Future { promise in promise(.success(1)) } URLSession.shared.dataTaskPublisher(for: url) NotificationCenter.default.publisher(for: .didUpdate) Timer.publish(every: 1, on: .main, in: .common).autoconnect() $searchTerm // from @Published

let value = try await publisher.values.first { _ in true } for await item in publisher.values { handle(item) }

struct ContentView: View { var body: some View { VStack(alignment: .leading, spacing: 12) { Text("Hello") .font(.title) .foregroundStyle(.primary) Text("World").font(.subheadline) } .padding() } }

VStack { } // vertical HStack { } // horizontal ZStack { } // layered Spacer() // pushes content apart Divider() Grid { GridRow { } }

Text("Hi").padding().background(.blue) // blue includes the padding Text("Hi").background(.blue).padding() // padding outside the blue

.frame(width: 100, height: 44) .frame(maxWidth: .infinity, alignment: .leading) .padding(.horizontal, 16) .background(.thinMaterial, in: .rect(cornerRadius: 12)) .opacity(0.8) .disabled(isBusy) .accessibilityLabel("Save")

struct Counter: View { @State private var count = 0 var body: some View { Button("Tapped \(count)") { count += 1 } } }

struct Parent: View { @State private var text = "" var body: some View { Child(text: $text) } } struct Child: View { @Binding var text: String var body: some View { TextField("Name", text: $text) } }

import Observation @Observable final class Model { var items: [Item] = [] var isLoading = false } struct ListView: View { @State private var model = Model() var body: some View { List(model.items) { Text($0.title) } } }

final class Model: ObservableObject { @Published var items: [Item] = [] } @StateObject private var model = Model() // owner @ObservedObject var model: Model // passed in @EnvironmentObject var session: Session // injected

@Environment(\.colorScheme) private var scheme @Environment(\.dismiss) private var dismiss @AppStorage("username") private var username = ""

List(items) { item in Text(item.title) } ForEach(items) { item in Row(item) } ForEach(0..<5, id: \.self) { i in Text("\(i)") }

NavigationStack(path: $path) { List(items) { item in NavigationLink(item.title, value: item) } .navigationTitle("Items") .navigationDestination(for: Item.self) { DetailView(item: $0) } }

.sheet(isPresented: $showing) { EditView() } .sheet(item: $selected) { DetailView(item: $0) } .alert("Delete?", isPresented: $confirming) { Button("Delete", role: .destructive) { delete() } Button("Cancel", role: .cancel) { } }

List(model.items) { Row($0) } .task { await model.load() } .refreshable { await model.reload() } .overlay { if model.isLoading { ProgressView() } }

withAnimation(.spring(duration: 0.3)) { isExpanded.toggle() } Circle() .scaleEffect(isExpanded ? 1.4 : 1) .animation(.easeInOut, value: isExpanded) .transition(.opacity.combined(with: .scale))

#Preview("Loaded") { ContentView() .environment(Model.sample) }

Image(systemName: "trash") .accessibilityLabel("Delete") .accessibilityHint("Removes this item permanently") .accessibilityAddTraits(.isButton) HStack { Text(name); Text(role) } .accessibilityElement(children: .combine) decorativeStripe.accessibilityHidden(true)

@Environment(\.dynamicTypeSize) private var typeSize @Environment(\.accessibilityReduceMotion) private var reduceMotion Text("Title").font(.title) // scales with Dynamic Type withAnimation(reduceMotion ? nil : .spring()) { expand() }

Text("welcome_title") // looked up automatically Text("Hello \(name)") // String Catalog picks it up String(localized: "cart.items", defaultValue: "\(count) items", comment: "Cart count")

final class DetailViewController: UIViewController { override func viewDidLoad() { super.viewDidLoad() // once, after the view is created } override func viewWillAppear(_ animated: Bool) { super.viewWillAppear(animated) // every time it is about to show } override func viewDidAppear(_ animated: Bool) { super.viewDidAppear(animated) } override func viewWillDisappear(_ animated: Bool) { super.viewWillDisappear(animated) } override func viewDidLayoutSubviews() { super.viewDidLayoutSubviews() } }

let vc = DetailViewController() vc.modalPresentationStyle = .pageSheet present(vc, animated: true) dismiss(animated: true) navigationController?.pushViewController(vc, animated: true) navigationController?.popViewController(animated: true)

let alert = UIAlertController(title: "Delete?", message: nil, preferredStyle: .alert) alert.addAction(UIAlertAction(title: "Delete", style: .destructive) { _ in self.delete() }) alert.addAction(UIAlertAction(title: "Cancel", style: .cancel)) present(alert, animated: true)

let label = UILabel() label.translatesAutoresizingMaskIntoConstraints = false view.addSubview(label) NSLayoutConstraint.activate([ label.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor, constant: 16), label.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 20), label.trailingAnchor.constraint(lessThanOrEqualTo: view.trailingAnchor, constant: -20) ])

let c = label.widthAnchor.constraint(equalToConstant: 200) c.priority = .defaultHigh // 750 c.isActive = true label.setContentHuggingPriority(.required, for: .horizontal) label.setContentCompressionResistancePriority(.required, for: .vertical)

let stack = UIStackView(arrangedSubviews: [title, subtitle]) stack.axis = .vertical stack.spacing = 8 stack.alignment = .leading stack.distribution = .fill

enum Section { case main } let dataSource = UITableViewDiffableDataSource<Section, Item.ID>( tableView: tableView ) { table, indexPath, id in let cell = table.dequeueReusableCell(withIdentifier: "Cell", for: indexPath) cell.contentConfiguration = self.configuration(for: id) return cell } var snapshot = NSDiffableDataSourceSnapshot<Section, Item.ID>() snapshot.appendSections([.main]) snapshot.appendItems(items.map(\.id)) await dataSource.apply(snapshot, animatingDifferences: true)

func tableView(_ t: UITableView, numberOfRowsInSection s: Int) -> Int { items.count } func tableView(_ t: UITableView, cellForRowAt i: IndexPath) -> UITableViewCell { let cell = t.dequeueReusableCell(withIdentifier: "Cell", for: i) return cell } func tableView(_ t: UITableView, didSelectRowAt i: IndexPath) { t.deselectRow(at: i, animated: true) }

let item = NSCollectionLayoutItem(layoutSize: .init( widthDimension: .fractionalWidth(1), heightDimension: .absolute(60))) let group = NSCollectionLayoutGroup.horizontal(layoutSize: .init( widthDimension: .fractionalWidth(1), heightDimension: .absolute(60)), subitems: [item]) let layout = UICollectionViewCompositionalLayout(section: .init(group: group))

button.addTarget(self, action: #selector(tapped), for: .touchUpInside) @objc private func tapped() { } // or with a closure, iOS 14 and later button.addAction(UIAction { _ in self.reload() }, for: .touchUpInside)

let tap = UITapGestureRecognizer(target: self, action: #selector(handleTap)) view.addGestureRecognizer(tap) view.isUserInteractionEnabled = true

let host = UIHostingController(rootView: ProfileView()) addChild(host) view.addSubview(host.view) host.didMove(toParent: self)

struct MapView: UIViewRepresentable { func makeUIView(context: Context) -> MKMapView { MKMapView() } func updateUIView(_ view: MKMapView, context: Context) { } func makeCoordinator() -> Coordinator { Coordinator() } }

import SwiftData @Model final class Task { var title: String var isDone: Bool var created: Date @Relationship(deleteRule: .cascade) var subtasks: [Task] = [] init(title: String, isDone: Bool = false) { self.title = title self.isDone = isDone self.created = .now } }

@main struct MyApp: App { var body: some Scene { WindowGroup { ContentView() } .modelContainer(for: Task.self) } }

struct TaskList: View { @Environment(\.modelContext) private var context @Query(sort: \Task.created, order: .reverse) private var tasks: [Task] var body: some View { List(tasks) { task in Text(task.title) } Button("Add") { context.insert(Task(title: "New")) } } }

@Query(filter: #Predicate<Task> { !$0.isDone }, sort: \Task.created) private var open: [Task] let descriptor = FetchDescriptor<Task>( predicate: #Predicate { $0.title.contains("swift") }) let found = try context.fetch(descriptor)

context.delete(task) try context.save() // usually automatic, explicit when you need it

let container = NSPersistentContainer(name: "Model") container.loadPersistentStores { _, error in if let error { fatalError("store failed: \(error)") } } let context = container.viewContext

let request: NSFetchRequest<TaskEntity> = TaskEntity.fetchRequest() request.predicate = NSPredicate(format: "isDone == %@", NSNumber(value: false)) request.sortDescriptors = [NSSortDescriptor(key: "created", ascending: false)] request.fetchLimit = 50 let results = try context.fetch(request)

let task = TaskEntity(context: context) task.title = "Write tests" context.delete(other) if context.hasChanges { try context.save() }

container.performBackgroundTask { bg in // bg is a private queue context, never touch it from the main thread let item = TaskEntity(context: bg) item.title = "Imported" try? bg.save() }

let url = URL.documentsDirectory.appending(path: "state.json") try JSONEncoder().encode(state).write(to: url, options: .atomic) let restored = try JSONDecoder().decode(State.self, from: Data(contentsOf: url))

let query: [String: Any] = [ kSecClass as String: kSecClassGenericPassword, kSecAttrAccount as String: "authToken", kSecValueData as String: Data(token.utf8) ] SecItemDelete(query as CFDictionary) let status = SecItemAdd(query as CFDictionary, nil) guard status == errSecSuccess else { throw KeychainError.save(status) }

// UserDefaults small preferences, plist backed // File on disk documents the user owns, exportable // Keychain credentials and tokens, encrypted // SwiftData structured, queryable, relational // Core Data the same, with a longer history and more control

struct User: Codable { let id: Int let name: String let email: String? } let data = try JSONEncoder().encode(user) let decoded = try JSONDecoder().decode(User.self, from: data) let list = try JSONDecoder().decode([User].self, from: data)

struct User: Codable { let id: Int let fullName: String enum CodingKeys: String, CodingKey { case id case fullName = "full_name" } }

let decoder = JSONDecoder() decoder.keyDecodingStrategy = .convertFromSnakeCase decoder.dateDecodingStrategy = .iso8601 let encoder = JSONEncoder() encoder.outputFormatting = [.prettyPrinted, .sortedKeys]

init(from decoder: Decoder) throws { let c = try decoder.container(keyedBy: CodingKeys.self) id = try c.decode(Int.self, forKey: .id) name = try c.decodeIfPresent(String.self, forKey: .name) ?? "Unknown" }

do { _ = try JSONDecoder().decode(User.self, from: data) } catch let DecodingError.keyNotFound(key, context) { print("missing \(key.stringValue): \(context.debugDescription)") } catch let DecodingError.typeMismatch(type, context) { print("expected \(type) at \(context.codingPath)") }

let url = URL(string: "https://api.example.com/users")! let (data, response) = try await URLSession.shared.data(from: url) guard let http = response as? HTTPURLResponse, (200..<300).contains(http.statusCode) else { throw APIError.badStatus } let users = try JSONDecoder().decode([User].self, from: data)

var request = URLRequest(url: url) request.httpMethod = "POST" request.setValue("application/json", forHTTPHeaderField: "Content-Type") request.httpBody = try JSONEncoder().encode(payload) let (data, _) = try await URLSession.shared.data(for: request)

var components = URLComponents(string: "https://api.example.com/search")! components.queryItems = [ URLQueryItem(name: "q", value: term), URLQueryItem(name: "page", value: "1") ] let url = components.url!

let now = Date() now.formatted(date: .abbreviated, time: .shortened) now.formatted(.relative(presentation: .named)) // "2 hours ago" let iso = ISO8601DateFormatter().string(from: now) let later = now.addingTimeInterval(3600) Calendar.current.date(byAdding: .day, value: 7, to: now)

let docs = URL.documentsDirectory let file = docs.appending(path: "notes.json") try data.write(to: file) let loaded = try Data(contentsOf: file) FileManager.default.fileExists(atPath: file.path()) try FileManager.default.removeItem(at: file)

UserDefaults.standard.set(true, forKey: "hasLaunched") UserDefaults.standard.bool(forKey: "hasLaunched") UserDefaults.standard.string(forKey: "username")

import Testing @Test func addsTwoNumbers() { #expect(add(2, 2) == 4) } @Test("Rejects an empty name") func rejectsEmpty() throws { #expect(throws: ValidationError.self) { try validate(name: "") } }

@Test(arguments: [1, 2, 3, 100]) func isPositive(_ value: Int) { #expect(value > 0) } @Test(arguments: zip(inputs, expected)) func converts(_ input: String, _ want: Int) throws { #expect(try convert(input) == want) }

@Suite("Parser") struct ParserTests { @Test(.tags(.slow)) func handlesLargeFile() async throws { } @Test(.disabled("flaky on CI")) func unstable() { } @Test(.timeLimit(.minutes(1))) func bounded() async { } }

@Test func decodes() throws { let user = try #require(try? decode(sample)) // unwraps or fails now #expect(user.name == "Ada") }

struct DatabaseTests { let db: Database init() async throws { db = try await Database.temporary() } // each test gets a fresh instance, no shared state }

import XCTest @testable import MyApp final class MathTests: XCTestCase { override func setUp() { } override func tearDown() { } func testAdd() { XCTAssertEqual(add(2, 2), 4) } }

XCTAssertEqual(a, b) XCTAssertTrue(flag) XCTAssertNil(value) XCTAssertThrowsError(try risky()) XCTAssertNoThrow(try safe()) XCTUnwrap(optional) // throws instead of crashing

func testLoad() async throws { let user = try await service.load(id: "1") XCTAssertEqual(user.name, "Ada") } func testCallback() { let exp = expectation(description: "finished") service.load { _ in exp.fulfill() } wait(for: [exp], timeout: 2) }

func testSortPerformance() { measure { _ = largeArray.sorted() } }

protocol UserLoading { func load(id: String) async throws -> User } struct ViewModel { let loader: UserLoading // not URLSession.shared init(loader: UserLoading = APIClient()) { self.loader = loader } }

final class LoaderSpy: UserLoading { private(set) var requested: [String] = [] var result: Result<User, Error> = .success(.sample) func load(id: String) async throws -> User { requested.append(id) return try result.get() } }

extension User { static let sample = User(id: "1", name: "Ada", email: nil) } // usable from tests and from #Preview alike

final class StubProtocol: URLProtocol { static var handler: ((URLRequest) -> (HTTPURLResponse, Data))? override class func canInit(with: URLRequest) -> Bool { true } override func startLoading() { } override func stopLoading() { } } let config = URLSessionConfiguration.ephemeral config.protocolClasses = [StubProtocol.self]

// Xcode breakpoint navigator, then the plus button: // All Exceptions stops where an ObjC exception is raised // Swift Error stops on any throw // Symbolic break on a symbol you do not have source for // Constraint Error stops on an Auto Layout conflict

// right click a breakpoint, Edit Breakpoint: // Condition index == 42 // Ignore skip the first N hits // Action Debugger Command, or Log Message // Options Automatically continue after evaluating

assert(index < count, "index out of range") // debug only assertionFailure("should not reach here") // debug only precondition(index < count) // debug and release fatalError("unrecoverable") // always, returns Never

import OSLog let log = Logger(subsystem: "com.example.app", category: "network") log.debug("requesting \(url, privacy: .public)") log.info("loaded \(items.count) items") log.error("failed: \(error.localizedDescription)")

print(#file, #line, #function) dump(model) // full structure, nested debugPrint(value) // uses debugDescription

let start = ContinuousClock.now work() print("took \(ContinuousClock.now - start)") let signposter = OSSignposter(subsystem: "app", category: "perf") let state = signposter.beginInterval("import") signposter.endInterval("import", state)

// Scheme, Diagnostics tab: // Address Sanitizer memory errors // Thread Sanitizer data races // Main Thread Checker UIKit called off the main thread // Malloc Scribble / Guard heap corruption // Zombie Objects messages to deallocated instances

deinit { print("\(Self.self) deinit") } // should fire when you expect // Xcode: Debug Memory Graph button, filter to your type, // then look at the inbound arrows that keep it alive.

// EXC_BAD_ACCESS touched deallocated or invalid memory // EXC_BREAKPOINT a Swift runtime trap: force unwrap of nil, // array index out of range, integer overflow // SIGABRT an assertion, precondition, or ObjC exception // Watchdog 0x8badf00d the main thread was blocked too long

atos -o MyApp.app.dSYM/Contents/Resources/DWARF/MyApp -l 0x100000000 0x1000123ab // keep the dSYM for every release build, it is the only way // to turn addresses back into file and line numbers

// swift-tools-version: 6.0 import PackageDescription let package = Package( name: "MyLibrary", platforms: [.iOS(.v17), .macOS(.v14)], products: [ .library(name: "MyLibrary", targets: ["MyLibrary"]) ], dependencies: [ .package(url: "https://github.com/apple/swift-algorithms", from: "1.2.0") ], targets: [ .target(name: "MyLibrary", dependencies: [ .product(name: "Algorithms", package: "swift-algorithms") ]), .testTarget(name: "MyLibraryTests", dependencies: ["MyLibrary"]) ] )

.package(url: url, from: "1.2.0") // 1.2.0 up to 2.0.0 .package(url: url, .upToNextMinor(from: "1.2.0")) .package(url: url, exact: "1.2.3") .package(url: url, branch: "main") .package(path: "../LocalPackage")

.target( name: "MyLibrary", swiftSettings: [ .enableUpcomingFeature("StrictConcurrency"), .swiftLanguageMode(.v6) // swift-tools-version 6.0 and later ] )

.target(name: "MyLibrary", resources: [ .process("Assets.xcassets"), .copy("seed.json") ]) let url = Bundle.module.url(forResource: "seed", withExtension: "json")

products: [ .library(name: "Core", targets: ["Core"]), .executable(name: "cli", targets: ["CLI"]) ], targets: [ .target(name: "Core"), .executableTarget(name: "CLI", dependencies: ["Core"]), .testTarget(name: "CoreTests", dependencies: ["Core"]) ]

import ArgumentParser @main struct Tool: ParsableCommand { @Argument(help: "File to read") var input: String @Option(name: .shortAndLong) var output: String = "out.txt" @Flag(name: .shortAndLong) var verbose = false func run() throws { } }

.binaryTarget(name: "Analytics", url: "https://…/Analytics.xcframework.zip", checksum: "abc123…") .systemLibrary(name: "CSQLite", pkgConfig: "sqlite3")

swift package show-dependencies --format tree swift package diagnose-api-breaking-changes 1.2.0 swift package resolve # commit Package.resolved for apps // libraries usually do not commit Package.resolved

@available(iOS 17, macOS 14, *) func modernOnly() { } if #available(iOS 17, *) { modernOnly() } else { fallback() }

@available(*, deprecated, renamed: "connect(to:)") func connect(url: URL) { } @available(*, unavailable, message: "Use the async version") func loadSync() { } @discardableResult func save() -> Bool { true }

#Preview { ContentView() } // SwiftUI preview @Observable final class Model { } // observation @Test func works() { } // Swift Testing #expect(a == b) #warning("finish this") #error("do not ship")

print(#file, #line, #function) print(#filePath) let literal = #"raw \n stays raw"#

@freestanding(expression) public macro stringify<T>(_ value: T) -> (T, String) = #externalMacro(module: "MyMacros", type: "StringifyMacro") let (result, code) = #stringify(2 + 3) // (5, "2 + 3")

@attached(member) // adds properties or methods @attached(peer) // adds declarations alongside @attached(accessor) // turns a stored property into computed @attached(extension, conformances: Codable)

@resultBuilder struct StringBuilder { static func buildBlock(_ parts: String...) -> String { parts.joined(separator: "\n") } static func buildOptional(_ part: String?) -> String { part ?? "" } static func buildEither(first: String) -> String { first } static func buildEither(second: String) -> String { second } static func buildArray(_ parts: [String]) -> String { parts.joined(separator: "\n") } }

@StringBuilder func report(showDetail: Bool) -> String { "Header" if showDetail { "Detail line" } for item in items { item.title } "Footer" }

@ViewBuilder // SwiftUI view bodies @SceneBuilder // App scenes @ToolbarContentBuilder @RegexComponentBuilder // RegexBuilder DSL

let name: String? = "Ada" print(name.count) // error // fix print(name?.count ?? 0) if let name { print(name.count) }

let total = 3 * 0.5 // fine, both are literals let count = 3 let bad = count * 0.5 // error // fix let good = Double(count) * 0.5

struct Counter { var value = 0 func bump() { value += 1 } // error } // fix: mutating func bump() { value += 1 }

let value = [] // error let coder = JSONDecoder().decode(from: data) // error // fix: say what you want let value: [Int] = [] let user = try JSONDecoder().decode(User.self, from: data)

func move(from a: Int, to b: Int) { } move(1, 2) // error // fix move(from: 1, to: 2)

struct User { let id: String let name: String init(id: String) { self.id = id } // error, name unset } // fix: set name, give it a default, or make it optional

struct User: Equatable { let handler: () -> Void // closures are not Equatable } // fix: remove the closure from the type, or write == by hand

struct Loader { var items: [Item] = [] mutating func load() { service.fetch { self.items = $0 } // error in a struct } } // fix: make Loader a class, or an actor, or hand the result back

// older Swift var repo: Repository = UserRepo() // error if it has associatedtype // fix, Swift 5.7 and later var repo: any Repository<User> = UserRepo() func use(_ repo: some Repository) { }

let user = loadUser() // error // fix: let user = await loadUser(), inside an async context or a Task

Task.detached { self.label.text = "done" // error, UI off the main actor } // fix Task { @MainActor in self.label.text = "done" }

final class Cache { var items: [String] = [] } Task { cache.items.append("x") } // error under Swift 6 // fix: make it an actor, or make the state immutable actor Cache { var items: [String] = [] }

// a long chain of + and ternaries in one expression // fix: split it into several lets and annotate the types let a: Double = base * factor let b: Double = a + offset

// most models want to be values struct User: Codable, Hashable { let id: UUID; var name: String } // use a class when you need identity or shared mutable state final class SessionStore { }

// not -1, not "", not a magic zero func index(of item: Item) -> Int? func load() throws -> Config

// three booleans allow eight states, only four are real var isLoading = false; var error: Error?; var items: [Item] = [] // one enum allows exactly the states that exist enum State { case idle, loading, loaded([Item]), failed(Error) }

extension User: Codable { } extension User: CustomStringConvertible { var description: String { name } } // each conformance in its own extension, easy to read and to move

@objc final class Bridge: NSObject { @objc func refresh() { } @objc var title: String = "" } @objcMembers final class Everything: NSObject { } // exposes all members

// App target: add the header to MyApp-Bridging-Header.h #import "LegacyManager.h" // Then use it directly let manager = LegacyManager() manager.start()

// Objective-C header - (nullable NSString *)nameFor:(NSInteger)id; // becomes String? - (nonnull NSString *)title; // becomes String // unannotated becomes String!, an implicitly unwrapped optional

@objc(TMSUserManager) final class UserManager: NSObject { @objc(refreshWithForce:) func refresh(force: Bool) { } }