State ↔ Binding

`$` gives you the projected value.

struct Parent: View {
  @State private var name = ""
  @State private var isOn = false

  var body: some View {
    VStack {
      Child(name: $name)                // pass a binding down
      Toggle("On", isOn: $isOn)
      Text(name)
    }
  }
}

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

// Derived / computed binding
let upper = Binding(
  get: { name.uppercased() },
  set: { name = $0.lowercased() }
)
// Optional -> non-optional binding
Binding($optionalName) ?? .constant("")

Environment injection

iOS 17+ `@Observable` works with plain `@Environment`.

@Observable final class Session { var user: User? }

// Inject
ContentView()
  .environment(session)                  // @Observable
  .environmentObject(legacyStore)        // ObservableObject (legacy)

// Consume
struct ProfileView: View {
  @Environment(Session.self) private var session
  @Environment(\.dismiss) private var dismiss
  @Environment(\.colorScheme) private var scheme

  var body: some View {
    Text(session.user?.name ?? "Guest")
    Button("Close") { dismiss() }
  }
}

// Custom environment value (iOS 17+ macro)
extension EnvironmentValues {
  @Entry var accentTheme: Theme = .default
}

Identity & lifetime rules

Where most SwiftUI bugs come from.

• @State initialisers run every body evaluation, but the value is kept — never rely on the initialiser running once for side effects.
• Creating an ObservableObject with @ObservedObject var vm = VM() recreates it on every render. Use @StateObject.
• Changing a view's structural identity (branch of if, position in a ForEach) destroys its @State.
• Give ForEach stable IDs (Identifiable), never array indices for mutable collections.
• .id(value) deliberately forces a fresh identity — useful to reset a subview.
• .task(id:) cancels and restarts when the id changes; it's tied to view lifetime.
• onAppear/onDisappear can fire multiple times (e.g. in NavigationStack); prefer .task for async work.

Async work in a view

struct FeedView: View {
  @State private var items: [Item] = []
  @State private var phase: Phase = .loading

  var body: some View {
    List(items) { ItemRow($0) }
      .task {                              // auto-cancelled on disappear
        do { items = try await api.feed() ; phase = .loaded }
        catch { phase = .failed(error) }
      }
      .refreshable {                       // pull-to-refresh, async by design
        items = (try? await api.feed()) ?? items
      }
      .task(id: selectedCategory) { ... }  // restart when the id changes
  }
}

Layout containers

SwiftUI layout = parent proposes a size, child chooses, parent places.

VStack(alignment: .leading, spacing: 8) { ... }
HStack(alignment: .firstTextBaseline) { ... }
ZStack(alignment: .bottomTrailing) { ... }

ScrollView { LazyVStack(pinnedViews: [.sectionHeaders]) { ... } }
ScrollView(.horizontal) { LazyHStack { ... } }

LazyVGrid(columns: [GridItem(.adaptive(minimum: 100), spacing: 8)]) { ... }

Grid {                                    // iOS 16+, true 2D alignment
  GridRow { Text("A"); Text("B") }
  GridRow { Text("C").gridCellColumns(2) }
}

ViewThatFits { WideLayout(); NarrowLayout() }
Spacer(); Divider()

Sizing & alignment

The order of modifiers matters — each one wraps the previous view.

Text("Hi")
  .padding(12)                 // pad first...
  .background(.blue)           // ...then background covers the padding
  .frame(maxWidth: .infinity, alignment: .leading)
  .frame(height: 44)
  .clipShape(.rect(cornerRadius: 12))

// .frame(width:height:) fixes a size
// .frame(maxWidth: .infinity) expands to fill the proposal
// .fixedSize() tells the child to use its ideal size (fixes truncated text)
// .layoutPriority(1) wins space in a stack

GeometryReader { proxy in                 // greedy: fills all offered space
  Circle().frame(width: proxy.size.width * 0.5)
}

Lists & collections

List {
  Section("Today") {
    ForEach(items) { item in
      NavigationLink(value: item) { ItemRow(item: item) }
        .swipeActions { Button("Delete", role: .destructive) { delete(item) } }
    }
    .onDelete { indexSet in items.remove(atOffsets: indexSet) }
    .onMove { from, to in items.move(fromOffsets: from, toOffset: to) }
  }
}
.listStyle(.insetGrouped)
.searchable(text: $query, prompt: "Search")
.navigationDestination(for: Item.self) { ItemDetail(item: $0) }
.toolbar { ToolbarItem(placement: .topBarTrailing) { EditButton() } }

// Editable rows: bind directly into the collection (iOS 15+)
ForEach($items) { $item in TextField("Name", text: $item.name) }

Navigation (vanilla SwiftUI)

NavigationStack(path: $path) {                    // path: [Route] or NavigationPath
  RootView()
    .navigationDestination(for: Route.self) { route in
      switch route {
      case .detail(let id): DetailView(id: id)
      case .settings:       SettingsView()
      }
    }
}
NavigationLink("Open", value: Route.detail(id))   // value-based, decoupled

path.append(Route.settings)      // programmatic push
path.removeLast()                // pop
path = NavigationPath()          // pop to root

NavigationSplitView { Sidebar() } detail: { Detail() }   // iPad / Mac

Animation & transitions

// Implicit — animates any change to values this view depends on
Circle().scaleEffect(scale).animation(.spring(duration: 0.3), value: scale)

// Explicit — animate the state change itself
withAnimation(.easeInOut(duration: 0.25)) { isExpanded.toggle() }

// Transitions for insertion/removal
if isShown {
  Banner().transition(.move(edge: .top).combined(with: .opacity))
}

// Matched geometry (hero animations)
@Namespace private var ns
Image(...).matchedGeometryEffect(id: "hero", in: ns)

// Phase / keyframe animation (iOS 17+)
.phaseAnimator([1.0, 1.2]) { view, phase in view.scaleEffect(phase) }
.sensoryFeedback(.success, trigger: didSave)

Reusable building blocks

// ViewModifier
struct CardStyle: ViewModifier {
  func body(content: Content) -> some View {
    content.padding(16)
      .background(.background.secondary, in: .rect(cornerRadius: 14))
      .shadow(radius: 2, y: 1)
  }
}
extension View { func card() -> some View { modifier(CardStyle()) } }

// @ViewBuilder for conditional content
@ViewBuilder
func statusView(_ s: Status) -> some View {
  switch s {
  case .loading: ProgressView()
  case .error(let e): Text(e.localizedDescription).foregroundStyle(.red)
  case .loaded(let items): List(items) { ItemRow($0) }
  }
}

// Generic container
struct Card<Content: View>: View {
  @ViewBuilder let content: () -> Content
  var body: some View { VStack { content() }.card() }
}

// PreferenceKey: child -> parent communication
struct HeightKey: PreferenceKey {
  static var defaultValue: CGFloat = 0
  static func reduce(value: inout CGFloat, nextValue: () -> CGFloat) {
    value = max(value, nextValue())
  }
}

Performance rules

• Keep body cheap and pure — it can run many times per frame.
• Split big views into small View structs so re-render scope stays tiny.
• Use Lazy* stacks/grids for long content; List already recycles.
• Avoid AnyView — it erases identity and defeats the diffing engine.
• Avoid heavy work or Date() inside body.
• GeometryReader in a stack collapses siblings; prefer .containerRelativeFrame or onGeometryChange (iOS 18).
• Equatable conformance + .equatable() can short-circuit expensive diffs.
• Instruments → *SwiftUI* template shows view body counts and cause-of-update.

Embedding UIKit in SwiftUI

`UIViewRepresentable` — know the 3 members + Coordinator.

struct TextViewRepresentable: UIViewRepresentable {
  @Binding var text: String

  func makeUIView(context: Context) -> UITextView {
    let tv = UITextView()
    tv.delegate = context.coordinator
    return tv
  }

  func updateUIView(_ tv: UITextView, context: Context) {
    if tv.text != text { tv.text = text }      // guard against feedback loops
  }

  func makeCoordinator() -> Coordinator { Coordinator(text: $text) }

  final class Coordinator: NSObject, UITextViewDelegate {
    let text: Binding<String>
    init(text: Binding<String>) { self.text = text }
    func textViewDidChange(_ tv: UITextView) { text.wrappedValue = tv.text }
  }
}

// Also: UIViewControllerRepresentable (same shape, makeUIViewController/updateUIViewController)

Embedding SwiftUI in UIKit

let host = UIHostingController(rootView: ProfileView(user: user))

// As a child view controller
addChild(host)
host.view.translatesAutoresizingMaskIntoConstraints = false
view.addSubview(host.view)
NSLayoutConstraint.activate([
  host.view.topAnchor.constraint(equalTo: view.topAnchor),
  host.view.leadingAnchor.constraint(equalTo: view.leadingAnchor),
  host.view.trailingAnchor.constraint(equalTo: view.trailingAnchor),
  host.view.bottomAnchor.constraint(equalTo: view.bottomAnchor),
])
host.didMove(toParent: self)

// As a cell (iOS 16+)
cell.contentConfiguration = UIHostingConfiguration { RowView(item: item) }

Interview talking points

• SwiftUI is declarative + state-driven: you describe *what* the UI is for a given state; the framework diffs and applies changes.
• Views are cheap value types recreated constantly; the persistent thing is the view *identity* and its attached state.
• UIKit is imperative + reference-based: you mutate a long-lived view object tree and must keep it in sync by hand.
• SwiftUI's weak spots: fine-grained scroll control, complex text editing, deep customisation → drop down via Representable.
• UIKit's diffable data source (NSDiffableDataSourceSnapshot) is the imperative world catching up to SwiftUI's diffing.
• Both can coexist screen-by-screen; migration is usually leaf-first.

The 5 nouns

Memorise this; every TCA answer starts here.

• State — a value type holding everything the feature needs to render.
• Action — an enum of *everything that can happen* (user intent + system results).
• Reducer — (inout State, Action) -> Effect<Action>. Pure, synchronous, testable.
• Store — runtime that holds state, runs the reducer, executes effects.
• Effect — the *only* place async / side effects live. Feeds actions back in.
• Golden rule: reducers never do async work; effects never mutate state.

Minimal feature

The skeleton you should be able to type from memory.

import ComposableArchitecture

@Reducer
struct Counter {
  @ObservableState
  struct State: Equatable {
    var count = 0
    var fact: String?
    var isLoading = false
  }

  enum Action {
    case incrementTapped
    case decrementTapped
    case factButtonTapped
    case factResponse(Result<String, Error>)
  }

  @Dependency(\.numberFact) var numberFact

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .incrementTapped:
        state.count += 1
        return .none

      case .decrementTapped:
        state.count -= 1
        return .none

      case .factButtonTapped:
        state.isLoading = true
        return .run { [count = state.count] send in
          await send(.factResponse(Result { try await numberFact.fetch(count) }))
        }

      case let .factResponse(.success(fact)):
        state.isLoading = false
        state.fact = fact
        return .none

      case .factResponse(.failure):
        state.isLoading = false
        return .none
      }
    }
  }
}

The view + entry point

`StoreOf<F>` is `Store<F.State, F.Action>`.

struct CounterView: View {
  let store: StoreOf<Counter>          // @Bindable var store  when you need bindings

  var body: some View {
    Form {
      // With @ObservableState you read state directly - no WithViewStore needed.
      Text("\(store.count)")
      Button("-") { store.send(.decrementTapped) }
      Button("+") { store.send(.incrementTapped) }
      if store.isLoading { ProgressView() }
      if let fact = store.fact { Text(fact) }
    }
  }
}

// App entry
@main
struct MyApp: App {
  static let store = Store(initialState: Counter.State()) {
    Counter()
      ._printChanges()               // debug: logs every action + state diff
  }
  var body: some Scene {
    WindowGroup { CounterView(store: Self.store) }
  }
}

Effects cheat list

Everything `Effect` gives you.

return .none                                   // no side effect

return .send(.otherAction)                     // synchronous follow-up (avoid for logic sharing)

return .run { send in                          // async work
  let value = try await api.load()
  await send(.loaded(value))
} catch: { error, send in
  await send(.failed(error))
}

return .merge(.run { ... }, .run { ... })      // run in parallel
return .concatenate(.run { ... }, .run { ... })// run in order

return .run { _ in await analytics.log("x") }  // fire-and-forget

// Cancellation
enum CancelID { case search, timer }
return .run { ... }.cancellable(id: CancelID.search, cancelInFlight: true)
return .cancel(id: CancelID.search)

Debounce & long-running effects

Debounced search + a timer effect started/stopped by actions.

@Dependency(\.continuousClock) var clock

case let .queryChanged(q):
  state.query = q
  return .run { send in
    try await clock.sleep(for: .milliseconds(300))    // debounce
    await send(.searchResponse(try await api.search(q)))
  }
  .cancellable(id: CancelID.search, cancelInFlight: true)

case .startTimerTapped:
  return .run { send in
    for await _ in clock.timer(interval: .seconds(1)) {
      await send(.timerTicked)
    }
  }
  .cancellable(id: CancelID.timer)

case .stopTimerTapped:
  return .cancel(id: CancelID.timer)

Bindings (two-way SwiftUI state)

`BindableAction` + `BindingReducer` + `@Bindable`.

@Reducer
struct Settings {
  @ObservableState
  struct State: Equatable {
    var displayName = ""
    var notificationsOn = false
  }

  enum Action: BindableAction {
    case binding(BindingAction<State>)
    case saveTapped
  }

  var body: some ReducerOf<Self> {
    BindingReducer()                       // must come before your Reduce
    Reduce { state, action in
      switch action {
      case .binding(\.notificationsOn):    // react to one specific binding
        return .run { _ in await push.sync() }
      case .binding, .saveTapped:
        return .none
      }
    }
  }
}

struct SettingsView: View {
  @Bindable var store: StoreOf<Settings>
  var body: some View {
    Form {
      TextField("Name", text: $store.displayName)
      Toggle("Notifications", isOn: $store.notificationsOn)
    }
  }
}

Shared state (across features)

`@Shared` replaces passing the same value up and down the tree.

// In-memory, app-scoped
extension SharedKey where Self == InMemoryKey<Int> {
  static var streak: Self { .inMemory("streak") }
}

@ObservableState
struct State: Equatable {
  @Shared(.appStorage("hasOnboarded")) var hasOnboarded = false
  @Shared(.streak) var streak = 0
}

// Mutating shared state inside a reducer:
state.$streak.withLock { $0 += 1 }

Scope: parent embeds child

One `Scope` per child domain, then the parent's own `Reduce`.

@Reducer
struct AppFeature {
  @ObservableState
  struct State: Equatable {
    var counter = Counter.State()
    var profile = Profile.State()
  }
  enum Action {
    case counter(Counter.Action)
    case profile(Profile.Action)
  }

  var body: some ReducerOf<Self> {
    Scope(state: \.counter, action: \.counter) { Counter() }
    Scope(state: \.profile, action: \.profile) { Profile() }

    Reduce { state, action in
      switch action {
      case .counter(.incrementTapped):        // parent can observe child actions
        state.profile.score += 1
        return .none
      case .counter, .profile:
        return .none
      }
    }
  }
}

// View side
CounterView(store: store.scope(state: \.counter, action: \.counter))

Optional & collection children

`ifLet` for optional state, `forEach` for identified collections.

@ObservableState
struct State: Equatable {
  var editor: Editor.State?                        // optional child
  var rows: IdentifiedArrayOf<Row.State> = []      // collection of children
}
enum Action {
  case editor(Editor.Action)
  case rows(IdentifiedActionOf<Row>)
}

var body: some ReducerOf<Self> {
  Reduce { ... }
    .ifLet(\.editor, action: \.editor) { Editor() }
    .forEach(\.rows, action: \.rows) { Row() }
}

// View
ForEach(store.scope(state: \.rows, action: \.rows)) { rowStore in
  RowView(store: rowStore)
}

Child → parent communication

Prefer a `delegate` action over the parent snooping on internals.

@Reducer
struct Row {
  enum Action {
    case deleteTapped
    case delegate(Delegate)                  // public API of the child
    enum Delegate: Equatable { case didRequestDelete(Row.State.ID) }
  }

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .deleteTapped:
        return .send(.delegate(.didRequestDelete(state.id)))
      case .delegate:
        return .none                          // parent handles it
      }
    }
  }
}

// Parent
case let .rows(.element(id: _, action: .delegate(.didRequestDelete(id)))):
  state.rows.remove(id: id)
  return .none

Dependency client

Struct-of-closures, not a protocol. Swappable, `Sendable`, no subclassing.

@DependencyClient
struct NumberFactClient {
  var fetch: @Sendable (Int) async throws -> String
}

extension NumberFactClient: DependencyKey {
  static let liveValue = Self { number in
    let url = URL(string: "http://numbersapi.com/\(number)")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return String(decoding: data, as: UTF8.self)
  }
  static let previewValue = Self { "\($0) is a preview number." }
  static let testValue = Self()               // unimplemented -> test fails if called
}

extension DependencyValues {
  var numberFact: NumberFactClient {
    get { self[NumberFactClient.self] }
    set { self[NumberFactClient.self] = newValue }
  }
}

Built-in dependencies worth knowing

Never reach for the global versions inside a reducer.

• Date() → use @Dependency(\.date.now)
• UUID() → use @Dependency(\.uuid) (.incrementing in tests)
• Task.sleep / Timer → use @Dependency(\.continuousClock) + TestClock
• Int.random(in:) → use @Dependency(\.withRandomNumberGenerator)
• @Dependency(\.mainQueue) for scheduler-based code, \.openURL, \.dismiss
• Override for a subtree: .dependency(\.uuid, .incrementing) on a reducer, or withDependencies { } operation: { }

TestStore — exhaustive testing

Every state mutation and every received action must be asserted.

@Test
func incrementAndFetchFact() async {
  let store = await TestStore(initialState: Counter.State()) {
    Counter()
  } withDependencies: {
    $0.numberFact.fetch = { "\($0) is a good number." }
  }

  await store.send(.incrementTapped) {
    $0.count = 1                        // assert the *diff* only
  }

  await store.send(.factButtonTapped) {
    $0.isLoading = true
  }

  await store.receive(\.factResponse.success) {
    $0.isLoading = false
    $0.fact = "1 is a good number."
  }
}

Testing time-based effects

`TestClock` makes debounce/timers instant and deterministic.

let clock = TestClock()
let store = await TestStore(initialState: Search.State()) {
  Search()
} withDependencies: {
  $0.continuousClock = clock
  $0.apiClient.search = { _ in ["swift"] }
}

await store.send(.queryChanged("sw")) { $0.query = "sw" }
await clock.advance(by: .milliseconds(300))
await store.receive(\.searchResponse) { $0.results = ["swift"] }

// Non-exhaustive style (integration tests):
store.exhaustivity = .off(showSkippedAssertions: true)

Pick your navigation style

• Tree-based — @Presents var destination: Destination.State?. Best for sheets, popovers, alerts, one-off drill-ins.
• Stack-based — var path = StackState<Path.State>(). Best for arbitrarily deep push navigation.
• Both make navigation *state-driven*: set state → screen appears. Deep links become State construction.
• @Presents gives you free dismissal handling: SwiftUI setting the binding to nil sends .dismiss.

Tree-based: sheet / popover / fullScreenCover

One enum reducer for all destinations of a screen.

@Reducer
struct Inventory {
  @Reducer
  enum Destination {                       // @Reducer on an enum = destination reducer
    case addItem(ItemForm)
    case detail(ItemDetail)
  }

  @ObservableState
  struct State: Equatable {
    @Presents var destination: Destination.State?
    var items: IdentifiedArrayOf<Item> = []
  }

  enum Action {
    case addTapped
    case itemTapped(Item.ID)
    case destination(PresentationAction<Destination.Action>)
  }

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .addTapped:
        state.destination = .addItem(ItemForm.State())
        return .none

      case let .itemTapped(id):
        guard let item = state.items[id: id] else { return .none }
        state.destination = .detail(ItemDetail.State(item: item))
        return .none

      // Listen to a child action across the presentation boundary:
      case let .destination(.presented(.addItem(.delegate(.saved(item))))):
        state.items.append(item)
        state.destination = nil            // programmatic dismiss
        return .none

      case .destination:
        return .none
      }
    }
    .ifLet(\.$destination, action: \.destination)
  }
}

Tree-based: the view side

`$store.scope` turns optional child state into a SwiftUI item binding.

struct InventoryView: View {
  @Bindable var store: StoreOf<Inventory>

  var body: some View {
    List {
      ForEach(store.items) { item in
        Button(item.name) { store.send(.itemTapped(item.id)) }
      }
    }
    .toolbar { Button("Add") { store.send(.addTapped) } }

    .sheet(item: $store.scope(state: \.destination?.addItem,
                              action: \.destination.addItem)) { formStore in
      NavigationStack { ItemFormView(store: formStore) }
    }

    .navigationDestination(item: $store.scope(state: \.destination?.detail,
                                              action: \.destination.detail)) { detailStore in
      ItemDetailView(store: detailStore)
    }
    // also: .popover(item:), .fullScreenCover(item:)
  }
}

Alerts & confirmation dialogs

`AlertState` keeps alerts testable — no view code decides anything.

@ObservableState
struct State: Equatable {
  @Presents var alert: AlertState<Action.Alert>?
}

enum Action {
  case deleteTapped
  case alert(PresentationAction<Alert>)
  @CasePathable enum Alert: Equatable { case confirmDelete }
}

case .deleteTapped:
  state.alert = AlertState {
    TextState("Delete this item?")
  } actions: {
    ButtonState(role: .destructive, action: .confirmDelete) { TextState("Delete") }
    ButtonState(role: .cancel) { TextState("Cancel") }
  } message: {
    TextState("This cannot be undone.")
  }
  return .none

case .alert(.presented(.confirmDelete)):
  state.items.remove(id: state.selectedID)
  return .none

case .alert:
  return .none

// reducer:  .ifLet(\.$alert, action: \.alert)
// view:     .alert($store.scope(state: \.alert, action: \.alert))

Stack-based navigation

`StackState` + `NavigationStack(path:)`. Deep links = appending to the path.

@Reducer
struct AppFeature {
  @Reducer
  enum Path {
    case detail(Detail)
    case settings(Settings)
  }

  @ObservableState
  struct State: Equatable {
    var path = StackState<Path.State>()
    var root = Root.State()
  }

  enum Action {
    case root(Root.Action)
    case path(StackActionOf<Path>)
  }

  var body: some ReducerOf<Self> {
    Scope(state: \.root, action: \.root) { Root() }
    Reduce { state, action in
      switch action {
      // React to an action from *any* Detail screen on the stack:
      case let .path(.element(id: id, action: .detail(.doneTapped))):
        state.path.pop(from: id)
        return .none
      case .root, .path:
        return .none
      }
    }
    .forEach(\.path, action: \.path)
  }
}

Stack-based: the view side

`NavigationLink(state:)` replaces `NavigationLink(destination:)`.

struct AppView: View {
  @Bindable var store: StoreOf<AppFeature>

  var body: some View {
    NavigationStack(path: $store.scope(state: \.path, action: \.path)) {
      RootView(store: store.scope(state: \.root, action: \.root))
    } destination: { store in
      switch store.case {                       // exhaustive over Path
      case let .detail(store):   DetailView(store: store)
      case let .settings(store): SettingsView(store: store)
      }
    }
  }
}

// Inside RootView — push by *state*, not by view:
NavigationLink(state: AppFeature.Path.State.detail(Detail.State(id: item.id))) {
  Text(item.name)
}

// Programmatic push / pop / deep link:
state.path.append(.detail(Detail.State(id: id)))
state.path.removeLast()
state.path = StackState([.settings(Settings.State())])

Dismissing yourself (child-initiated)

`@Dependency(\.dismiss)` — the child doesn't need to know its parent.

@Reducer
struct ItemForm {
  @Dependency(\.dismiss) var dismiss

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .cancelTapped:
        return .run { _ in await self.dismiss() }   // must be in .run, not sync
      ...
      }
    }
  }
}

async / await basics

`await` = a possible suspension point, not a thread hop guarantee.

func loadUser(id: Int) async throws -> User {
  let (data, response) = try await URLSession.shared.data(from: url(id))
  guard (response as? HTTPURLResponse)?.statusCode == 200 else { throw APIError.badStatus }
  return try JSONDecoder().decode(User.self, from: data)
}

// Sequential: total time = a + b
let user = try await loadUser(id: 1)
let posts = try await loadPosts(for: user)

// Concurrent: total time = max(a, b)
async let user  = loadUser(id: 1)
async let stats = loadStats(id: 1)
let (u, s) = try await (user, stats)      // both awaited here

Structured vs unstructured

Interviewers love this distinction.

• Structured: async let, TaskGroup. Child tasks cannot outlive the scope; cancellation and errors propagate automatically.
• Unstructured: Task { } — inherits actor isolation + priority, but you must retain/cancel it yourself.
• Detached: Task.detached { } — inherits *nothing*. Rarely the right answer; only for truly independent background work.
• Rule of thumb: use structured concurrency; Task { } only at the boundary between sync (e.g. a SwiftUI button) and async code.

TaskGroup — dynamic fan-out

Use when the number of child tasks is only known at runtime.

func thumbnails(for ids: [String]) async throws -> [String: UIImage] {
  try await withThrowingTaskGroup(of: (String, UIImage).self) { group in
    for id in ids {
      group.addTask { (id, try await fetchThumbnail(id)) }   // runs concurrently
    }
    var result: [String: UIImage] = [:]
    for try await (id, image) in group {                     // results in COMPLETION order
      result[id] = image
    }
    return result
  }
}

// Bounded concurrency (don't launch 10 000 tasks):
try await withThrowingTaskGroup(of: Void.self) { group in
  var it = ids.makeIterator()
  for _ in 0..<4 { if let id = it.next() { group.addTask { try await work(id) } } }
  while try await group.next() != nil {
    if let id = it.next() { group.addTask { try await work(id) } }
  }
}

Cancellation

Cooperative: nothing is killed, you must check.

Task.isCancelled                       // non-throwing check
try Task.checkCancellation()           // throws CancellationError

let task = Task {
  for chunk in chunks {
    try Task.checkCancellation()
    await process(chunk)
  }
}
task.cancel()                          // cancels task AND all its children
await task.value                       // await result (rethrows)

// Clean up when cancelled mid-flight:
await withTaskCancellationHandler {
  try await longRunningWork()
} onCancel: {
  connection.close()                   // runs immediately, sync, on any thread
}

// try await Task.sleep(...) throws CancellationError immediately on cancel.

AsyncSequence & AsyncStream

Bridge callbacks/delegates into async, and iterate over time.

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

// Produce — bridging a callback API
func locations() -> AsyncStream<CLLocation> {
  AsyncStream { continuation in
    let manager = LocationManager()
    manager.onUpdate = { continuation.yield($0) }
    continuation.onTermination = { _ in manager.stop() }
    manager.start()
  }
}

// Throwing variant + explicit finish
let stream = AsyncThrowingStream<Int, Error> { c in
  c.yield(1); c.yield(2); c.finish()
}

// Operators exist too:
for await x in stream.map { $0 * 2 }.filter({ $0 > 2 }).prefix(10) { ... }

Bridging legacy callbacks

Continuations: resume exactly once, or you crash / leak.

func load() async throws -> Data {
  try await withCheckedThrowingContinuation { continuation in
    legacyLoad { data, error in
      if let error { continuation.resume(throwing: error) }
      else { continuation.resume(returning: data!) }
    }
  }
}

// Cancellable version
func load() async throws -> Data {
  try await withTaskCancellationHandler {
    try await withCheckedThrowingContinuation { c in
      task = legacyLoad { ... }
    }
  } onCancel: { task?.cancel() }
}

// withUnsafeContinuation = same, no runtime checks. Use Checked while developing.

MainActor hop

Only touch UI on the main actor; the compiler enforces it in Swift 6.

@MainActor
final class ProfileViewModel: ObservableObject {
  @Published private(set) var user: User?

  func load() async {                     // inherits @MainActor
    let fetched = try? await api.user()   // api call suspends off the main actor
    self.user = fetched                   // back on main automatically
  }
}

// Explicit hop from a nonisolated context:
await MainActor.run { label.text = "done" }

// Already on main and need it synchronously (e.g. in a delegate callback):
MainActor.assumeIsolated { label.text = "done" }   // traps if not actually on main

actor = reference type with a serial executor

Mutable state protected by the compiler.

actor ImageCache {
  private var cache: [URL: UIImage] = [:]        // isolated: only reachable via await

  func image(for url: URL) -> UIImage? { cache[url] }     // implicitly async from outside

  func insert(_ image: UIImage, for url: URL) { cache[url] = image }

  nonisolated let name: String = "images"        // immutable -> no isolation needed
  nonisolated func describe() -> String { "Cache(\(name))" }
}

let cache = ImageCache()
await cache.insert(image, for: url)              // cross-actor call = await
let img = await cache.image(for: url)

Actor reentrancy — the classic trap

Every `await` inside an actor is a chance for other calls to interleave.

actor Downloader {
  private var cache: [URL: Data] = [:]
  private var inFlight: [URL: Task<Data, Error>] = [:]

  // BUG: two callers can both see an empty cache and both download.
  func badFetch(_ url: URL) async throws -> Data {
    if let hit = cache[url] { return hit }
    let data = try await URLSession.shared.data(from: url).0   // <-- suspension!
    cache[url] = data
    return data
  }

  // FIX: store the *task*, not just the result, before suspending.
  func fetch(_ url: URL) async throws -> Data {
    if let hit = cache[url] { return hit }
    if let running = inFlight[url] { return try await running.value }
    let task = Task { try await URLSession.shared.data(from: url).0 }
    inFlight[url] = task
    defer { inFlight[url] = nil }
    let data = try await task.value
    cache[url] = data
    return data
  }
}

Sendable in one screen

What can safely cross an isolation boundary.

• struct/enum of Sendable members → implicit Sendable (if not public; public needs explicit conformance).
• final class with only let Sendable properties → can be Sendable.
• actor types are always Sendable.
• Non-final classes and classes with var state are not Sendable.
• @unchecked Sendable = "I promise I lock correctly." Only with a real mutex/queue inside.
• @Sendable on closures: no capture of non-Sendable state, no mutable captures.
• sending parameters (SE-0430) transfer ownership across isolation without needing Sendable.

Global actors & custom isolation

`@MainActor` is just the built-in global actor.

@globalActor
actor DatabaseActor {
  static let shared = DatabaseActor()
}

@DatabaseActor
final class Store {
  private var rows: [Row] = []          // all members isolated to DatabaseActor
  func insert(_ r: Row) { rows.append(r) }
}

@DatabaseActor func migrate() async { ... }

// Opting a member out
@MainActor
final class VM {
  nonisolated let id = UUID()
  nonisolated func pureHelper(_ x: Int) -> Int { x * 2 }
}

Isolated & sending parameters

Advanced but very quotable in an interview.

// Run code *in* someone else's isolation domain
func mutate(_ cache: isolated ImageCache, url: URL) {
  cache.evict(url)                        // no await needed: we're isolated to it
}

// Transfer a non-Sendable value across a boundary (compiler proves no other refs)
func handOff(_ model: sending NonSendableModel) async {
  await actor.consume(model)
}

// #isolation gives the caller's isolation to a generic API
func run(isolation: isolated (any Actor)? = #isolation, _ body: () async -> Void) async {
  await body()
}

Do

• Mark model types Sendable and keep them value types.
• Put @MainActor on view models / anything touching UIKit or SwiftUI state.
• Use nonisolated for pure helpers so callers don't need await.
• Prefer async let / TaskGroup over manually spawned Tasks.
• Store Task handles you need to cancel (and cancel in deinit / onDisappear).
• Use Task.sleep, ContinuousClock, or an injected clock instead of Thread.sleep/Timer.
• Turn on SWIFT_STRICT_CONCURRENCY = complete per-module and migrate incrementally.
• Use @preconcurrency import to silence a legacy module while you migrate.

Don't

• Don't use DispatchSemaphore/DispatchGroup.wait() to make async look sync.
• Don't sprinkle Task { } inside loops — that's unstructured and unbounded.
• Don't use Task.detached just to "get off the main thread"; a nonisolated async func already does.
• Don't add @unchecked Sendable to silence errors without a real lock.
• Don't assume state is unchanged across an await inside an actor (reentrancy).
• Don't capture self strongly in a long-lived Task on a view controller.
• Don't resume a continuation twice (crash) or zero times (leak + hang).
• Don't rely on Thread.current — a task can resume on any thread.

Making a legacy delegate Swift 6 safe

Common migration exercise.

// The delegate protocol is not isolated; the callback arrives on an unknown thread.
final class Scanner: NSObject, ScannerDelegate {
  private let continuation: AsyncStream<Code>.Continuation
  let codes: AsyncStream<Code>

  override init() {
    var c: AsyncStream<Code>.Continuation!
    codes = AsyncStream { c = $0 }
    continuation = c
    super.init()
  }

  nonisolated func scanner(_ s: RawScanner, didFind code: Code) {
    continuation.yield(code)          // Continuation is Sendable -> safe from any thread
  }
}

// Consumer stays on the main actor:
@MainActor
func observe(_ scanner: Scanner) async {
  for await code in scanner.codes { self.lastCode = code }
}

Talking points

Short answers that show depth.

• GCD threads *block*; Swift concurrency tasks *suspend* and free the thread. That's why blocking a cooperative thread is so bad.
• await does not guarantee a thread change; it guarantees the correct isolation domain.
• Thread explosion: 1000 DispatchQueue.global().async calls can spawn ~64+ threads. TaskGroup is bounded by the core count.
• Priority inversion: GCD needs manual QoS care; Swift concurrency escalates priority automatically for actor/task dependencies.
• Combine is still the right answer for UIKit-era reactive pipelines and for @Published; new code usually prefers AsyncSequence + Observation.

Mental model

• Publisher<Output, Failure> emits 0…n values then either .finished or .failure — never both, never after.
• Subscriber requests demand (backpressure). sink/assign request .unlimited.
• A pipeline is inert until subscribed, and dies when its AnyCancellable deallocates.
• Failure == Never means the compiler knows it can't fail — required by assign(to:on:).
• .eraseToAnyPublisher() hides the huge generic type at API boundaries.

Creating publishers

Just(42)                                   // one value, then finish. Failure == Never
Empty<Int, Never>()                        // finish immediately
Fail<Int, MyError>(error: .boom)           // fail immediately
[1, 2, 3].publisher                        // Sequence
Future<Int, Error> { promise in            // single async result, EAGER
  api.load { promise(.success($0)) }
}
Deferred { Future { ... } }                // make Future lazy (one call per subscriber)

URLSession.shared.dataTaskPublisher(for: url)
Timer.publish(every: 1, on: .main, in: .common).autoconnect()
NotificationCenter.default.publisher(for: UIApplication.didBecomeActiveNotification)
$searchText                                // @Published projected value

Subjects — imperative bridge into Combine

let events = PassthroughSubject<Event, Never>()      // no memory of last value
let state  = CurrentValueSubject<State, Never>(.idle) // replays current value on subscribe

events.send(.tapped)
state.send(.loading)
state.value = .loaded          // CurrentValueSubject only
events.send(completion: .finished)

// @Published is a CurrentValueSubject in disguise
final class VM: ObservableObject {
  @Published var query = ""
  @Published private(set) var results: [Item] = []
}

Networking pipeline

The canonical whiteboard answer.

func search(_ query: String) -> AnyPublisher<[Repo], APIError> {
  var components = URLComponents(string: "https://api.github.com/search/repositories")!
  components.queryItems = [.init(name: "q", value: query)]

  return URLSession.shared.dataTaskPublisher(for: components.url!)
    .tryMap { data, response in
      guard let http = response as? HTTPURLResponse, 200..<300 ~= http.statusCode else {
        throw APIError.badStatus
      }
      return data
    }
    .decode(type: SearchResponse.self, decoder: JSONDecoder())
    .map(\.items)
    .mapError { $0 as? APIError ?? .underlying($0) }
    .receive(on: DispatchQueue.main)
    .eraseToAnyPublisher()
}

// Wiring it up
$query
  .debounce(for: .milliseconds(300), scheduler: RunLoop.main)
  .removeDuplicates()
  .filter { $0.count > 2 }
  .map { [search] q in search(q).catch { _ in Just([]) } }
  .switchToLatest()
  .assign(to: &$repos)

Subscribing & lifetime

private var cancellables = Set<AnyCancellable>()

publisher
  .sink(
    receiveCompletion: { completion in
      if case let .failure(error) = completion { self.show(error) }
    },
    receiveValue: { value in self.items = value }
  )
  .store(in: &cancellables)

// Failure == Never shortcuts
publisher.sink { self.items = $0 }.store(in: &cancellables)
publisher.assign(to: \.text, on: label).store(in: &cancellables)
publisher.assign(to: &$items)              // @Published target, no cancellable needed

// assign(to:on:) retains `on` -> use [weak self] in sink instead of assign(to:on: self)

Combine gotchas

• Future is eager — it runs at creation, not at subscription. Wrap in Deferred.
• Forgetting .store(in:) → pipeline cancelled immediately, nothing happens.
• assign(to:\.x, on: self) creates a retain cycle. Use sink { [weak self] }.
• subscribe(on:) affects the *subscription*, receive(on:) affects delivery downstream of it.
• An error terminates the stream forever. Use catch/replaceError inside a flatMap to keep the outer stream alive.
• Combine has no built-in backpressure control in sink — it requests unlimited demand.

Observing UIKit/system events

Both worlds, same event.

// Combine
NotificationCenter.default
  .publisher(for: UIResponder.keyboardWillShowNotification)
  .compactMap { $0.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect }
  .map(\.height)
  .assign(to: &$keyboardHeight)

// async/await
for await note in NotificationCenter.default.notifications(
      named: UIResponder.keyboardWillShowNotification) {
  guard let frame = note.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect
  else { continue }
  keyboardHeight = frame.height
}

Which do I reach for?

• async/await — request/response, sequential logic, anything new, anything you must unit test simply.
• Combine — @Published glue in UIKit/pre-Observation SwiftUI, complex multi-source operator chains, debounce/throttle for free.
• GCD — only when interoperating with old code, or for DispatchSource-level primitives.
• You can mix: expose AsyncStream from a Combine pipeline via .values, or wrap an async call in Deferred { Future { } }.

The connection points

There are only a handful. Know all of them.

• ObservableObject + @Published — the object *is* a publisher; SwiftUI subscribes to objectWillChange.
• .onReceive(publisher) { value in } — subscribe to any publisher for the view's lifetime.
• assign(to: &$published) — pipe a publisher straight into a @Published property (no cancellable needed).
• objectWillChange.send() — manual notification when you don't use @Published.
• .task { for await x in publisher.values { } } — bridge Combine into structured concurrency.
• With @Observable (iOS 17+) there is no objectWillChange and no @Published; Combine becomes an *input* only.

The classic ViewModel

Combine-powered `ObservableObject`, driving a SwiftUI view.

@MainActor
final class SearchViewModel: ObservableObject {
  @Published var query = ""                       // input from the view
  @Published private(set) var results: [Repo] = []
  @Published private(set) var isLoading = false
  @Published private(set) var errorMessage: String?

  private var cancellables = Set<AnyCancellable>()

  init(api: API = .live) {
    $query
      .debounce(for: .milliseconds(300), scheduler: RunLoop.main)
      .removeDuplicates()
      .filter { $0.count >= 2 }
      .handleEvents(receiveOutput: { [weak self] _ in self?.isLoading = true })
      .map { q in
        api.search(q)
          .catch { _ in Just<[Repo]>([]) }        // keep the OUTER stream alive
      }
      .switchToLatest()                            // cancels the previous request
      .receive(on: RunLoop.main)
      .handleEvents(receiveOutput: { [weak self] _ in self?.isLoading = false })
      .assign(to: &$results)                       // no cancellable to store
  }
}

struct SearchView: View {
  @StateObject private var vm = SearchViewModel()

  var body: some View {
    List(vm.results) { RepoRow($0) }
      .searchable(text: $vm.query)                 // two-way binding into @Published
      .overlay { if vm.isLoading { ProgressView() } }
  }
}

Derived / validated state

`CombineLatest` is the idiomatic form-validation answer.

final class SignUpViewModel: ObservableObject {
  @Published var email = ""
  @Published var password = ""
  @Published var confirmation = ""
  @Published private(set) var isValid = false
  @Published private(set) var passwordHint: String?

  private var bag = Set<AnyCancellable>()

  init() {
    let validEmail = $email.map { $0.contains("@") && $0.count > 5 }
    let validPassword = Publishers.CombineLatest($password, $confirmation)
      .map { pwd, confirm in pwd.count >= 8 && pwd == confirm }

    Publishers.CombineLatest(validEmail, validPassword)
      .map { $0 && $1 }
      .removeDuplicates()
      .assign(to: &$isValid)

    $password
      .map { $0.count >= 8 ? nil : "At least 8 characters" }
      .assign(to: &$passwordHint)
  }
}

// View
Button("Create account") { vm.submit() }
  .disabled(!vm.isValid)

Manual objectWillChange

When your state isn't in `@Published` properties.

final class Document: ObservableObject {
  private(set) var text: String = "" {
    willSet { objectWillChange.send() }    // must fire BEFORE the change
  }

  func append(_ s: String) { text += s }
}

// Republishing a child object's changes to the parent
final class Parent: ObservableObject {
  @Published var child = Child()
  private var bag = Set<AnyCancellable>()

  init() {
    child.objectWillChange
      .sink { [weak self] in self?.objectWillChange.send() }
      .store(in: &bag)                     // nested ObservableObjects are NOT automatic
  }
}

Bridging both ways inside a view

Combine in, async out — and vice versa.

// Combine publisher -> async iteration, scoped to the view's lifetime
.task {
  for await location in locationManager.publisher.values {
    region = MKCoordinateRegion(center: location.coordinate, span: span)
  }
}

// @Observable model that still consumes a legacy Combine API
@Observable
final class LocationModel {
  private(set) var last: CLLocation?
  @ObservationIgnored private var bag = Set<AnyCancellable>()

  init(service: LegacyLocationService) {
    service.publisher
      .receive(on: RunLoop.main)
      .sink { [weak self] in self?.last = $0 }   // plain assignment triggers Observation
      .store(in: &bag)
  }
}

SwiftUI + Combine pitfalls

• Building a publisher inside body / onReceive(...) — it is recreated every render. Build it in init or store it in a let.
• @ObservedObject var vm = VM() — recreated on each render. Use @StateObject (or @State with @Observable).
• Forgetting .receive(on: RunLoop.main) before touching UI state (or mark the VM @MainActor).
• An error reaching the outer publisher kills the stream permanently — catch inside the flatMap/map+switchToLatest.
• assign(to: \.x, on: self) retains self. Prefer assign(to: &$published) or sink { [weak self] }.
• Nested ObservableObjects don't propagate; forward objectWillChange manually or flatten the model.
• DispatchQueue.main vs RunLoop.main: RunLoop.main pauses during scroll tracking (often what you want for search); DispatchQueue.main always delivers.
• New code: prefer @Observable + async/await; keep Combine for debounce/throttle/multi-source merges and legacy APIs.

The conceptual split

This is the part people get wrong — the operators are the easy bit.

• Push vs pull. A Combine publisher *pushes* whenever it likes; an AsyncSequence is *pulled* by its consumer. So Combine needs buffer/debounce to protect a slow consumer, while for await naturally applies backpressure — the producer waits for you.
• Who owns the timer. In Combine the operator owns it, invisibly, and is torn down with the AnyCancellable. In async code *you* own a Task — if you don't store and cancel it, it leaks or fires after the screen is gone.
• Scheduler vs clock. Combine takes a Scheduler (where *and* when work runs). Concurrency splits those: the clock decides *when* (ContinuousClock, SuspendingClock) and the actor decides *where*.
• Cancellation. AnyCancellable.cancel() tears the chain down synchronously. Task.cancel() is *cooperative* — a sleep throws, but your own loop must check Task.isCancelled.
• Failure ends everything. A Combine error terminates the stream permanently; there is no "resume". A thrown error ends one for try await loop — you can just start another.
• Hot vs cold. Timer.publish is a ConnectablePublisher (nothing until .autoconnect() or .connect()). An AsyncStream starts producing when its closure runs, whether or not anyone iterates — so bound its buffer.
• Practical rule: use Combine's operators when you're already in a Combine pipeline. In new code, model time with an injected Clock and own your Tasks.

Repeating timers, without drift

Sleeping for the interval accumulates every millisecond of overhead.

// WRONG: each iteration is interval + however long tick() took.
// After an hour you've drifted seconds.
while !Task.isCancelled {
  try await Task.sleep(for: .seconds(1))
  await tick()
}

// RIGHT: advance an absolute deadline, so the work's cost is absorbed.
func run() async throws {
  let clock = ContinuousClock()
  var next = clock.now
  while !Task.isCancelled {
    next = next.advanced(by: .seconds(1))
    try await clock.sleep(until: next, tolerance: .milliseconds(50))
    await tick()                       // late ticks don't shift the schedule
  }
}

// swift-async-algorithms does it for you
for await instant in AsyncTimerSequence(interval: .seconds(1), clock: .continuous) {
  await tick()
}

// Combine equivalent - the operator handles the schedule, you handle the lifetime
Timer.publish(every: 1, on: .main, in: .common)
  .autoconnect()                       // ConnectablePublisher: nothing happens without this
  .sink { _ in tick() }
  .store(in: &cancellables)

Make time injectable — and your tests instant

// Depend on the `Clock` protocol, never on Task.sleep directly.
struct Poller<C: Clock> {
  let clock: C
  let interval: C.Duration

  func run(_ body: @Sendable () async -> Void) async throws {
    var next = clock.now
    while !Task.isCancelled {
      next = next.advanced(by: interval)
      try await clock.sleep(until: next, tolerance: nil)
      await body()
    }
  }
}

// Production
let poller = Poller(clock: ContinuousClock(), interval: .seconds(30))

// Tests: pointfreeco/swift-clocks — time only moves when you say so
@Test func pollsEverySecond() async throws {
  let clock = TestClock()
  var ticks = 0
  let task = Task { try await Poller(clock: clock, interval: .seconds(1))
                        .run { ticks += 1 } }
  await clock.advance(by: .seconds(3))
  #expect(ticks == 3)
  task.cancel()
}

// TCA gives you this as a dependency out of the box:
@Dependency(\.continuousClock) var clock

// Combine equivalent: inject the scheduler type
final class Model<S: Scheduler> {
  init(scheduler: S) { ... }        // ImmediateScheduler or a TestScheduler in tests
}

Owning the Task safely

Most async-timing bugs are lifetime bugs, not timing bugs.

// The state that a timer touches must live in ONE isolation domain.
@MainActor
final class TickerViewModel {
  private(set) var seconds = 0
  private var task: Task<Void, Never>?      // only ever touched on the main actor

  func start() {
    task?.cancel()                          // idempotent: no double timers
    task = Task { [weak self] in            // weak: don't keep the screen alive
      let clock = ContinuousClock()
      var next = clock.now
      while !Task.isCancelled {
        next = next.advanced(by: .seconds(1))
        try? await clock.sleep(until: next, tolerance: .milliseconds(50))
        guard let self, !Task.isCancelled else { return }
        self.seconds += 1                   // already on the main actor
      }
    }
  }

  func stop() { task?.cancel(); task = nil }
  deinit { task?.cancel() }
}

// In SwiftUI, prefer the framework's ownership - it cancels on disappear for you:
.task { await model.runTicker() }           // tied to the view's lifetime
.task(id: query) { await debouncedSearch() } // restarts when `query` changes

// Never Task.detached for a timer: it inherits no isolation and no cancellation,
// so it outlives the screen and races whatever it touches.

Safety checklist for async timing

• Store every long-lived Task and cancel it in stop() / onDisappear / deinit.
• Cancel before restarting (task?.cancel() then reassign) — otherwise you accumulate timers.
• Re-check Task.isCancelled after every await; a sleep that throws is not the same as a loop that stops.
• Keep the mutated state and the Task handle in the same isolation domain (@MainActor or one actor).
• Use absolute deadlines (clock.sleep(until:)) for anything periodic, so the work's cost doesn't accumulate as drift.
• Pass a tolerance on long sleeps so the OS can coalesce wakeups — it's real battery.
• Inject the Clock. A test that sleeps for real is a test that will flake in CI.
• Don't use Date() differences to measure elapsed time — the wall clock can move backwards.
• Don't Task.detached a timer, and don't spawn one per row/cell/view update.
• Don't hold a strong self in a repeating task — the screen can never deallocate.
• Don't Thread.sleep or busy-wait in async code; it blocks a cooperative thread that other tasks need.
• In Combine, the mirror-image rules are: always .store(in:), always .autoconnect() a Timer, and know whether your scheduler is RunLoop.main (pauses) or DispatchQueue.main (doesn't).

The short version

If you can only remember five things.

• Names reveal intent. A good name removes the need for a comment.
• Functions do one thing, at one level of abstraction, and are small.
• Fewer arguments is better. 0 > 1 > 2 > 3. Flags are a smell.
• No surprises. A function's name should predict its side effects — ideally there are none.
• The boy scout rule. Leave the code cleaner than you found it; refactor in small, safe steps.
• Clean code is optimised for *reading*. Code is read far more often than it is written.

Code smells checklist

Say these names when reviewing code out loud.

• Long function / god object — many reasons to change, hard to name.
• Deep nesting — invert conditions and use guard for early exit.
• Duplicated logic — the third copy is when you extract.
• Primitive obsession — String for an id/email; use a typed wrapper.
• Feature envy — a method that mostly touches another type's data; move it.
• Shotgun surgery — one change forces edits in ten files; the abstraction is wrong.
• Temporal coupling — configure() must be called before start(); enforce it in the initialiser.
• Boolean blindness — several Bools that encode one state; use an enum.

Typed wrappers beat primitives

Cheap in Swift, and the compiler catches whole bug classes.

struct UserID: Hashable, Codable, RawRepresentable { let rawValue: String }
struct Email: Hashable {
  let value: String
  init?(_ raw: String) {
    guard raw.contains("@") else { return nil }   // parse, don't validate later
    value = raw
  }
}

func message(from: UserID, to: UserID) { }
message(from: sender, to: recipient)     // can't accidentally swap with an order id

// Units
struct Meters: Numeric { ... }
let distance: Meters = 400

Clean tests (F.I.R.S.T.)

• Fast — milliseconds. No network, no sleeps: inject a clock.
• Independent — order must not matter; no shared mutable state between tests.
• Repeatable — inject Date, UUID, randomness. No flakiness.
• Self-validating — a pass/fail assertion, never manual inspection of a log.
• Timely — written with (or before) the code.
• One logical assertion per test; name it test_whenX_thenY. Arrange / Act / Assert structure.

Arrange–Act–Assert

@Test
func refund_isRejected_whenOrderIsOlderThan30Days() throws {
  // Arrange
  let order = Order.stub(placedAt: .distantPast, state: .delivered)
  let sut = RefundService(now: { .fixed })      // injected clock -> repeatable

  // Act
  let result = sut.eligibility(for: order)

  // Assert
  #expect(result == .rejected(reason: .expired))
}

// "sut" = system under test. Keep stubs in factory helpers so the
// test body shows only what is RELEVANT to this case.

The one-line versions

• Single Responsibility — a type has one reason to change.
• Open/Closed — open for extension, closed for modification.
• Liskov Substitution — a subtype must be usable anywhere its supertype is, without surprises.
• Interface Segregation — many small protocols beat one fat protocol.
• Dependency Inversion — depend on abstractions, and let the caller supply them.
• In Swift, protocols + value types + closures do most of the work; you rarely need class hierarchies.

Related principles they may also ask

• DRY — but prefer duplication over the wrong abstraction.
• YAGNI — don't build the protocol until there are two implementations.
• Composition over inheritance — Swift protocols + generics + structs make this the default.
• Law of Demeter — a.b.c.d() is a coupling smell; ask for what you need.
• Tell, don't ask — send a message rather than querying state and deciding externally.
• TCA angle: reducers = SRP, @Dependency = DIP, Scope/ifLet = composition over inheritance.

Core ideas

• Pure function — same input → same output, no observable side effects. Trivially testable and parallelisable.
• Immutability — let by default; model changes as new values, not mutations.
• Value semantics — struct/enum copy on assignment, so no shared-state races.
• First-class functions — pass, return and store functions like any value.
• Declarative — describe *what*, not the loop mechanics.
• Algebraic data types — struct = AND (product), enum = OR (sum). Make illegal states unrepresentable.
• Swift is multi-paradigm: use FP where it clarifies (transforms, pipelines), not dogmatically.

KeyPaths as functions

Concise, and a favourite trick in interviews.

let names = users.map(\.name)                       // KeyPath as (User) -> String
let sorted = users.sorted(using: KeyPathComparator(\.createdAt))
let grouped = Dictionary(grouping: users, by: \.country)
let ids = Set(users.map(\.id))

// Generic helper built on a key path
func by<T, V: Comparable>(_ kp: KeyPath<T, V>) -> (T, T) -> Bool {
  { $0[keyPath: kp] < $1[keyPath: kp] }
}
users.sorted(by: by(\.age))

Function composition & currying

infix operator >>>: AdditionPrecedence
func >>> <A, B, C>(f: @escaping (A) -> B, g: @escaping (B) -> C) -> (A) -> C {
  { a in g(f(a)) }
}

let trim: (String) -> String = { $0.trimmingCharacters(in: .whitespaces) }
let lower: (String) -> String = { $0.lowercased() }
let normalize = trim >>> lower

// Currying: turn a 2-arg function into a chain of 1-arg functions
func curry<A, B, C>(_ f: @escaping (A, B) -> C) -> (A) -> (B) -> C {
  { a in { b in f(a, b) } }
}
let add = curry(+)
let inc = add(1)                       // (Int) -> Int
[1, 2, 3].map(inc)                     // [2, 3, 4]

Optional & Result as containers

`map`/`flatMap` are not just for arrays.

// Optional chaining is flatMap
let length: Int? = name.map(\.count)                 // Optional<Int>
let user: User? = id.flatMap(repository.user(id:))   // avoids Optional<Optional<User>>

// Coalescing + guard for early exit
guard let email = form.email, email.contains("@") else { throw ValidationError.email }

// Result
let parsed = Result { try JSONDecoder().decode(User.self, from: data) }
  .map(\.name)
  .mapError(APIError.decoding)

switch parsed {
case .success(let name): print(name)
case .failure(let error): report(error)
}

try parsed.get()                         // back to throwing world

Make illegal states unrepresentable

The highest-value FP idea in day-to-day Swift.

// Bad: 4 booleans = 16 states, 12 of which are nonsense
struct ViewState {
  var isLoading = false
  var items: [Item] = []
  var error: Error?
}

// Good: exactly 4 possible states
enum ViewState {
  case idle
  case loading
  case loaded([Item])
  case failed(Error)
}

// Enums with associated values + exhaustive switch = compiler-checked logic
switch state {
case .idle:            EmptyView()
case .loading:         ProgressView()
case .loaded(let xs):  List(xs) { ItemRow($0) }
case .failed(let e):   ErrorView(error: e)
}

Laziness, memoization & pure transforms

// Lazy: no intermediate arrays, work happens on demand
let firstBig = numbers.lazy
  .map(expensiveTransform)
  .first { $0 > 1_000 }

// Infinite sequence
let evens = sequence(first: 0) { $0 + 2 }.prefix(5)   // 0,2,4,6,8

// Memoize a pure function
func memoize<A: Hashable, B>(_ f: @escaping (A) -> B) -> (A) -> B {
  var cache: [A: B] = [:]
  return { a in
    if let hit = cache[a] { return hit }
    let value = f(a); cache[a] = value; return value
  }
}

// Pure update on a value type
func updating<T>(_ value: T, _ mutate: (inout T) -> Void) -> T {
  var copy = value; mutate(&copy); return copy
}
let renamed = updating(user) { $0.name = "Ada" }

Trade-offs to mention out loud

• Pure functions are trivially unit-testable and thread-safe — a natural fit for Swift 6 Sendable.
• Value semantics remove whole classes of aliasing bugs; SwiftUI and TCA are built on it.
• Copying large structs can cost; Swift's CoW helps, but measure (isKnownUniquelyReferenced for custom CoW).
• Deep operator chains can hurt readability and compile times — name intermediate steps.
• inout and mutating are the pragmatic escape hatch: local mutation, value semantics preserved.

Generics & constraints

func first<T: Equatable>(_ value: T, in items: [T]) -> Int? {
  items.firstIndex(of: value)
}

struct Stack<Element> {
  private var storage: [Element] = []
  mutating func push(_ e: Element) { storage.append(e) }
  mutating func pop() -> Element? { storage.popLast() }
  var isEmpty: Bool { storage.isEmpty }
}

extension Stack where Element: Comparable {       // conditional extension
  var max: Element? { storage.max() }
}
extension Stack: Equatable where Element: Equatable { }

// where clauses on associated types
func sum<S: Sequence>(_ s: S) -> Int where S.Element == Int {
  s.reduce(0, +)
}

Protocols with associated types & primary associated types

protocol Repository {
  associatedtype Item: Identifiable
  func all() async throws -> [Item]
  func save(_ item: Item) async throws
}

// Swift 5.7 primary associated types make PATs usable as `some`/`any`
protocol Storage<Value> {
  associatedtype Value
  func load() -> Value?
}
func use(_ s: some Storage<User>) { ... }
let boxed: any Storage<User> = KeychainStorage()

// Protocol with default implementation
extension Repository {
  func first() async throws -> Item? { try await all().first }
}

Error handling

enum APIError: Error, Equatable {
  case badStatus(Int)
  case decoding(String)
}
extension APIError: LocalizedError {
  var errorDescription: String? {
    switch self {
    case .badStatus(let c): "Server returned \(c)"
    case .decoding(let m):  "Could not read the response: \(m)"
    }
  }
}

do { let u = try await api.user() }
catch let e as APIError { show(e) }
catch { report(error) }

try? await api.user()          // Optional result
try! JSONDecoder().decode(...) // crash on failure - tests/known-good only

// Typed throws (Swift 6)
func load() throws(APIError) -> User { ... }

defer { file.close() }         // runs on every exit path (LIFO)

Memory & ARC

class Node {
  var next: Node?
  weak var parent: Node?          // weak: optional, becomes nil
  unowned let owner: Owner        // unowned: non-optional, crashes if accessed after dealloc
}

// Closure capture lists
button.onTap = { [weak self] in
  guard let self else { return }
  self.reload()
}
Task { [weak self] in await self?.load() }

// Escaping vs non-escaping
func run(_ body: () -> Void) { body() }                 // non-escaping (default)
func store(_ body: @escaping () -> Void) { self.h = body }

// Retain-cycle checklist: delegate (weak), closures capturing self,
// Combine .assign(to:on: self), timers with strong targets, NotificationCenter observers.

Value vs reference semantics

struct Point { var x = 0 }          // value: copy on assign
final class Box { var x = 0 }       // reference: shared

var a = Point(); var b = a; b.x = 1   // a.x == 0
let p = Box(); let q = p; q.x = 1     // p.x == 1

// Copy-on-write for a custom buffer
struct Buffer {
  private var storage = Storage()
  mutating func mutate() {
    if !isKnownUniquelyReferenced(&storage) { storage = storage.copy() }
    storage.value += 1
  }
}

Pattern matching & control flow

The syntax you forget under pressure.

switch value {
case let .success(user) where user.isAdmin: grantAdmin(user)
case .success(let user):                    grant(user)
case .failure(APIError.badStatus(401)):     signOut()
case .failure:                              showRetry()
}

if case let .loaded(items) = state, !items.isEmpty { render(items) }
guard case .loading = state else { return }

for case let .some(x) in optionals { ... }
for (i, item) in items.enumerated() { ... }

let range = 1...10          // closed
0..<items.count             // half-open
if (0...100).contains(score) { ... }

// Result builders (how SwiftUI's DSL works)
@resultBuilder
enum StringBuilder {
  static func buildBlock(_ parts: String...) -> String { parts.joined(separator: " ") }
}