Swift Vocabulary

Swift optional unwrapping vocabulary:

Optional
An optional (String?) is a value that is either a String or nil. Before using it, you must unwrap it.

if let — conditional binding

if let name = user.name {
    print(name)  // name is String here
}
// name not accessible outside

The bound constant (name) exists only inside the if block. Leads to "pyramid of doom" with multiple optionals.

guard let — early exit binding

guard let name = user.name else {
    return  // exit early if nil
}
print(name)  // name is String for the rest of function

guard requires an exit (return, throw, break, continue, or fatalError()) in the else block. The bound constant is available after the guard statement — ideal for precondition checks.

Force unwrap !
user.name! — crashes with a runtime error if nil. Use only when you are 100% certain the value is non-nil (e.g., a static asset that must exist).

Optional chaining ?.
user.address?.city — returns nil if any value in the chain is nil, rather than crashing.

Nil coalescing ??
user.name ?? "Anonymous" — provide a default value if nil.

Vocabulary:
• optional — a value or nil; String?
• unwrap — extract the value from an optional
• golden path / happy path — the main logic flow with all conditions satisfied
• pyramid of doom — deeply nested if let chains

Value type (struct) vs reference type (class) vocabulary:

Value type (struct, enum):
When you assign or pass a value type, a copy is made:
var a = Point(x: 1, y: 2) var b = a b.x = 10 print(a.x) // 1 — a is unaffected

Reference type (class):
When you assign a reference type, both variables point to the same instance:
let a = User(name: "Alice") let b = a b.name = "Bob" print(a.name) // "Bob" — same instance

Which to use?
Apple's guidance: prefer structs by default. Use classes when:
• You need Objective-C interoperability
• You need identity semantics (===)
• The type has a lifecycle (delegate, view controller)
• Reference semantics are intentional (shared mutable state is desired and controlled)

mutating keyword:
Methods on a struct that modify its properties must be marked mutating. This signals that the caller's copy will be modified (or rather replaced with the modified copy).

Vocabulary:
• value type — copied on assignment; struct, enum, tuple
• reference type — shared on assignment; class, actor
• identity (===) — checks if two references point to the same object instance
• equality (==) — checks if two values are equal (Equatable protocol)
• mutating — method on a struct that modifies the instance
• copy-on-write (CoW) — Swift standard library types (Array, Dictionary) use CoW: actual copying happens lazily only when a mutation occurs

Closures, ARC, and retain cycles:

ARC (Automatic Reference Counting)
Swift manages memory automatically via ARC. Each object has a retain count — ARC deallocates the object when the count reaches 0. A strong reference increments the retain count.

Retain cycle (memory leak):
If Object A holds a strong reference to B, and B holds a strong reference to A — both retain counts stay ≥ 1, and neither is ever deallocated.

Common pattern in UIKit:

class ViewModel {
    var onUpdate: (() -> Void)?  // ViewModel owns the closure
}
class ViewController {
    let vm = ViewModel()
    func setup() {
        vm.onUpdate = {
            self.updateUI()  // closure captures self strongly
            // ViewController → ViewModel → closure → ViewController ♻️
        }
    }
}

Fix: capture list [weak self]
vm.onUpdate = { [weak self] in self?.updateUI() // self is now Optional; no cycle }
A weak reference does NOT increment the retain count. If the object is deallocated, the weak reference becomes nil.

[unowned self] — alternative:
[unowned self] also avoids a retain cycle but does NOT become nil after deallocation. If the object is already deallocated and you access unowned self, it crashes. Use only when you are certain the object outlives the closure.

@escaping:
A closure marked @escaping outlives the function that accepted it (stored, run later asynchronously). Escaping closures are where capture lists matter most.

Vocabulary:
• ARC — Automatic Reference Counting; Swift's memory management model
• retain count — number of strong references to an object
• retain cycle — circular strong reference preventing deallocation (memory leak)
• capture list — [weak x, unowned y] at the start of a closure
• @escaping — closure that outlives its enclosing function
• @noescape (default) — closure guaranteed to execute before function returns

Opaque types (some) and existential types (any):

some Protocol — opaque return type (Swift 5.1+)
The function returns a specific, single concrete type that conforms to the protocol, but the caller doesn't see which. The compiler knows the concrete type and uses static dispatch (fast, optimisable).

Rule: all return paths must return the same concrete type.

func makeAnimal() -> some Animal { return Dog() // always Dog; cannot return Cat on one path and Dog on another }

SwiftUI example:
var body: some View { Text("Hello") }
The body is always a specific View type. SwiftUI uses this for performance — no dynamic dispatch needed.

any Protocol — existential type (Swift 5.7+)
The function can return any conforming type — the concrete type is determined at runtime. Requires dynamic dispatch (slower). Swift 5.7 made any explicit to signal this cost.

func makeAnyAnimal() -> any Animal { return Bool.random() ? Dog() : Cat() // different types on each call }

Protocol — Swift's key abstraction:
A protocol defines a contract (required methods and properties). Types conform to protocols; Swift uses structural typing — no inheritance required.

Protocol extension — add default implementations to a protocol; all conforming types inherit the default behavior.

Vocabulary:
• protocol — defines required methods/properties; similar to interface in other languages
• conformance — a type implementing all protocol requirements
• opaque type (some) — caller-hidden concrete type; statically dispatched
• existential (any) — runtime-determined concrete type; dynamically dispatched
• protocol extension — default implementations for protocol requirements
• associated type — a placeholder type in a protocol (like generics for protocols)

Swift Concurrency vocabulary:

The data race problem
When two threads read and write shared mutable state simultaneously without synchronisation, you get undefined behaviour. Traditional fix: DispatchQueue serial queues or NSLock.

Actor (Swift 5.5+)
An actor is a reference type with automatic isolation — only one execution can access its mutable state at a time. No explicit locks needed; the compiler enforces isolation.

actor ImageCache { private var cache: [String: UIImage] = [:] func store(_ image: UIImage, for key: String) { cache[key] = image // safe — only one caller at a time } func image(for key: String) -> UIImage? { return cache[key] } }

Calling an actor from outside requires await: await imageCache.store(img, for: "avatar")

MainActor
@MainActor is a global actor that ensures code runs on the main thread. Annotate a class, function, or property:
@MainActor class ViewModel { ... }
Replaces DispatchQueue.main.async with compile-time enforcement.

async/await
• async func fetchData() -> Data — can suspend without blocking a thread
• await data = fetchData() — suspends until the result is ready
• Task { await ... } — creates a new concurrent task (unstructured)
• async let a = fetch(); async let b = fetch(); let result = await (a, b) — parallel execution

Vocabulary:
• actor — reference type with automatic serial access to mutable state
• actor isolation — the property that mutable state cannot be accessed concurrently
• @MainActor — global actor for UI / main-thread-only code
• async/await — cooperative concurrency model (Swift 5.5+)
• Task — a unit of async work; Task.detached for unstructured tasks
• Sendable — a type safe to share across concurrency boundaries (no data races)
• structured concurrency — async tasks follow a parent-child hierarchy; cancellation propagates