Swift Basics

if let binds the unwrapped value only inside its own braces. guard let binds into the enclosing scope and forces its else to exit (return, throw, break). guard reads better for early-exit validation, keeping the happy path unindented.

An optional (Optional<Wrapped>, i.e. T?) either holds a value (.some) or is nil (.none). It makes absence explicit in the type system, so the compiler forces you to handle nil — eliminating unexpected null-dereference crashes.

Inserting at index 0 is O(n) — a Swift Array stores elements contiguously, so every existing element shifts one slot right. Appending at the end is amortized O(1). For frequent front insertion, use another structure or build reversed.

Array is index-ordered — index access O(1), membership search O(n). Set and Dictionary are unordered hash tables with average O(1) lookup. A Set requires its elements (a Dictionary its keys) to be Hashable, so equal values hash alike.

defer blocks run as the scope exits — here at return — in LIFO order, so the last-registered runs first. It prints body, then B, then A; the returned 42 prints last, after load() returns. Output — body, B, A, 42.

A raw value is one compile-time constant per case, all of the same backing type (Int, String, …), so the compiler synthesizes a failable init?(rawValue:). An associated value attaches different runtime data per case. A case has one, not both.

An implicitly unwrapped optional (T!) is force-unwrapped automatically on every access. @IBOutlet uses one because the view is nil at init but connected before the view loads. It crashes if you access it while still nil, e.g. before viewDidLoad.

let is a constant, var a mutable variable. On a value-type struct, let freezes the whole value — you can't reassign or mutate a stored property. On a reference-type class, let fixes only the reference; the object stays mutable.

Safe — if let/guard let bind locally, ?? gives a default, ?. chains to nil on any nil link, case let destructures. Unsafe — force-unwrap ! traps on nil. Prefer the binding forms; reserve ! for provably non-nil values.

Match each case with value binding — case let .deposit(amount) — and add a where guard for a refined branch, e.g. case let .deposit(a) where a > 1000. Since the enum is finite, an exhaustive switch needs no default and flags any unhandled new case.

Optional chaining evaluates left to right and short-circuits — if a is nil, all of a?.b?.c is nil without touching b/c. The result is optional, so ?? d supplies d when nil. The chain can't crash, but d or a force-unwrap inside can.

An enum is a value type stored inline, so a case holding the enum's own type would need infinite size. indirect stores that case's value behind a pointer (a heap box), not inline, breaking the size recursion. You mark one case or the whole enum indirect.

typealias gives an existing type a readable second name — it creates no new type. A tuple groups a few values into a lightweight, unnamed ad-hoc type. Unlike a struct, a tuple can't conform to protocols, hold methods, or be extended.