┌─────────────────────────────────────────────┐
│  Your app                                    │
├─────────────────────────────────────────────┤
│  Interface   SwiftUI · WidgetKit · RealityKit│
├─────────────────────────────────────────────┤
│  Capability  SwiftData · StoreKit · HealthKit│
│              FoundationModels · MapKit · ... │
├─────────────────────────────────────────────┤
│  Foundation  Swift stdlib · Foundation       │
│              Observation · Swift Concurrency │
└─────────────────────────────────────────────┘

let name = "Jerry"        // constant, can't change
var count = 0             // variable, can change
count += 1

let pi: Double = 3.14159  // explicit type annotation
let flag = true           // inferred as Bool

let i: Int = 42
let d: Double = 3.14
let s: String = "hello"
let b: Bool = true
let arr: [Int] = [1, 2, 3]                    // array
let dict: [String: Int] = ["a": 1, "b": 2]    // dictionary
let set: Set<Int> = [1, 2, 3]                 // set: unordered, unique
let tuple: (name: String, age: Int) = ("Jerry", 30)  // tuple

let age = 30
print("My name is \(name) and I'm \(age)")

let text = """
    first line
    second line
    """

var nickname: String? = nil    // no nickname yet
nickname = "Jer"               // now there is one

// 1. if let — enter the branch only if there's a value
if let nickname {
    print("Nickname is \(nickname)")   // here nickname is String, not String?
} else {
    print("No nickname")
}

// 2. guard let — bail out early if there's no value (preferred at the top of a function)
func greet(_ nickname: String?) {
    guard let nickname else {
        print("No nickname, can't greet")
        return
    }
    print("Hello, \(nickname)")     // unwrapped for the rest of the function
}

// 3. ?? — supply a default
let display = nickname ?? "Anonymous"

let length = nickname?.count      // Int?; nil overall when nickname is nil

// if / else
if count > 10 { print("many") } else { print("few") }

// for-in
for i in 1...5 { print(i) }        // 1,2,3,4,5 (closed range)
for i in 1..<5 { print(i) }        // 1,2,3,4 (half-open range)
for item in arr { print(item) }
for (key, value) in dict { print("\(key)=\(value)") }

// while
while count < 10 { count += 1 }

// switch — Swift's switch must be exhaustive
let score = 85
switch score {
case 90...100: print("excellent")
case 60..<90:  print("pass")
default:       print("fail")
}

let point = (x: 1, y: 0)
switch point {
case (0, 0):            print("origin")
case (_, 0):            print("on the X axis")
case (0, _):            print("on the Y axis")
case let (x, y) where x == y: print("on the diagonal")
default:                print("somewhere else")
}

// basic function
func add(_ a: Int, _ b: Int) -> Int {
    a + b        // single-expression functions can omit return
}

// argument labels: external name + internal name
func greet(person name: String, from city: String) -> String {
    "Hello \(name), from \(city)"
}
greet(person: "Jerry", from: "Beijing")

// default values
func makeCoffee(size: String = "medium", sugar: Int = 0) { }
makeCoffee()                  // uses defaults
makeCoffee(size: "large")

// variadic parameters
func sum(_ numbers: Int...) -> Int { numbers.reduce(0, +) }

// multiple return values via tuples
func minMax(_ arr: [Int]) -> (min: Int, max: Int)? {
    guard let first = arr.first else { return nil }
    return arr.reduce((first, first)) { (min($0.0, $1), max($0.1, $1)) }
}

// full form
let double: (Int) -> Int = { (x: Int) -> Int in return x * 2 }
// shorter: type inference + implicit return
let double2: (Int) -> Int = { x in x * 2 }
// shortest: $0 for the first parameter
let double3: (Int) -> Int = { $0 * 2 }

// trailing closure: when the last parameter is a closure, write it outside the parens
let sorted = [3, 1, 2].sorted { $0 < $1 }
let doubled = [1, 2, 3].map { $0 * 2 }         // [2, 4, 6]
let evens = [1, 2, 3, 4].filter { $0 % 2 == 0 } // [2, 4]
let total = [1, 2, 3].reduce(0, +)              // 6

Button("Tap me") {          // this {} is the action closure
    print("tapped")
}

// struct — value type, copied on assignment
struct Person {
    var name: String
    var age: Int

    // computed property
    var isAdult: Bool { age >= 18 }

    // method
    func greeting() -> String { "I'm \(name)" }

    // methods that mutate self must be marked mutating
    mutating func birthday() { age += 1 }
}

var a = Person(name: "Jerry", age: 30)
var b = a          // a copy; a and b are independent
b.name = "Tom"
print(a.name)      // still "Jerry"

// class — reference type, shares the same object on assignment
class Counter {
    var value = 0
    func increment() { value += 1 }

    init(start: Int = 0) { value = start }   // classes need an init (unless every property has a default)
    deinit { print("deallocated") }
}

let c1 = Counter()
let c2 = c1        // c1 and c2 point at the same object
c2.increment()
print(c1.value)    // 1

// enum — Swift's enums are unusually powerful
enum LoadState {
    case idle
    case loading
    case loaded(items: [String])    // associated values
    case failed(Error)
}

let state = LoadState.loaded(items: ["a", "b"])
switch state {
case .idle:              print("idle")
case .loading:           print("loading")
case .loaded(let items): print("loaded \(items.count) items")
case .failed(let error): print("failed: \(error)")
}

// raw-value enum
enum Direction: String, CaseIterable {
    case north = "N", south = "S", east = "E", west = "W"
}
Direction.allCases.forEach { print($0.rawValue) }

struct Settings {
    var volume: Double = 0.5 {
        willSet { print("about to change from \(volume) to \(newValue)") }
        didSet  { print("changed from \(oldValue) to \(volume)") }
    }

    lazy var expensiveThing = computeSomethingSlow()   // computed on first access
}

enum NetworkError: Error {
    case notFound
    case unauthorized
    case server(code: Int)
}

func fetch(id: Int) throws -> String {
    guard id > 0 else { throw NetworkError.notFound }
    return "data \(id)"
}

// callers must handle it
do {
    let data = try fetch(id: 1)
    print(data)
} catch NetworkError.notFound {
    print("not found")
} catch {
    print("other error: \(error)")
}

// try? — returns nil on failure
let data = try? fetch(id: -1)      // String?

// try! — crashes on failure; use sparingly

extension NetworkError: LocalizedError {
    var errorDescription: String? {
        switch self {
        case .notFound:      "Couldn't find that."
        case .unauthorized:  "Please sign in first."
        case .server(let c): "Server error (\(c))"
        }
    }
}

// 1. anyAppleOS — shorthand replacing all five platform names
@available(anyAppleOS 27, *)
func newFeature() { }

// previously you'd write:
// @available(iOS 27, macOS 27, watchOS 27, tvOS 27, visionOS 27, *)

// works in conditional compilation too
#if os(anyAppleOS)
    func makeWidget() -> some Widget { ... }
#endif

// carve out individual platforms as usual
@available(anyAppleOS 27, *)
@available(tvOS, unavailable)
func launch() { }

// 2. async code inside defer
func process() async throws {
    let handle = try await openResource()
    defer { await handle.close() }    // runs whether you return normally or throw
    try await doWork(with: handle)
}

// 3. @diagnose — finer-grained control over warnings

protocol Drawable {
    var area: Double { get }        // requires a read-only property
    func draw()                     // requires a method
}

struct Circle: Drawable {
    let radius: Double
    var area: Double { .pi * radius * radius }
    func draw() { print("drawing a circle") }
}

extension Drawable {
    func describe() { print("a shape with area \(area)") }
    func draw() { print("default drawing") }    // conformers may skip draw
}

struct Todo: Identifiable, Codable, Hashable {
    let id = UUID()
    var title: String
    var done = false
}
// That's it: JSON coding, deduplication, and SwiftUI lists all work now.

extension String {
    var isValidEmail: Bool {
        contains("@") && contains(".")
    }
}
"[email protected]".isValidEmail    // true

extension Double {
    var asCurrency: String {
        formatted(.currency(code: "USD"))
    }
}

func firstElement<T>(of array: [T]) -> T? {
    array.first
}

// constrained generics
func maxElement<T: Comparable>(of array: [T]) -> T? {
    array.max()
}

// generic types
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>()
s.push(1); s.push(2)

func makeShape() -> some Drawable { Circle(radius: 1) }
//                  ↑ "one specific type that I'm not naming" — resolved at compile time, fast

func processAny(_ shape: any Drawable) { shape.draw() }
//                       ↑ "any type conforming to this protocol" — dynamic dispatch, works in heterogeneous arrays

class Parent { var child: Child? }
class Child { weak var parent: Parent? }    // weak breaks the cycle

class ViewModel {
    var onUpdate: (() -> Void)?
    func setup() {
        onUpdate = { [weak self] in         // [weak self] avoids the cycle
            guard let self else { return }
            self.doSomething()
        }
    }
    func doSomething() {}
}

func loadUser(id: Int) async throws -> User {
    let url = URL(string: "https://api.example.com/user/\(id)")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return try JSONDecoder().decode(User.self, from: data)
}

// calling it
Task {
    do {
        let user = try await loadUser(id: 1)
        print(user.name)
    } catch {
        print("failed: \(error)")
    }
}

// serial: total time = A + B
let a = try await loadUser(id: 1)
let b = try await loadUser(id: 2)

// parallel: total time = max(A, B)
async let userA = loadUser(id: 1)
async let userB = loadUser(id: 2)
let (a2, b2) = try await (userA, userB)

// use a TaskGroup when the count isn't fixed
func loadAll(ids: [Int]) async throws -> [User] {
    try await withThrowingTaskGroup(of: User.self) { group in
        for id in ids {
            group.addTask { try await loadUser(id: id) }
        }
        var results: [User] = []
        for try await user in group { results.append(user) }
        return results
    }
}

let task = Task {
    for i in 0..<1000 {
        try Task.checkCancellation()    // check whether we've been cancelled
        await process(i)
    }
}
task.cancel()

struct UserView: View {
    @State private var user: User?

    var body: some View {
        Text(user?.name ?? "Loading")
            .task {                       // starts when the view appears, cancels when it goes away
                user = try? await loadUser(id: 1)
            }
    }
}

actor ImageCache {
    private var cache: [URL: Data] = [:]

    func image(for url: URL) -> Data? { cache[url] }
    func store(_ data: Data, for url: URL) { cache[url] = data }
}

let cache = ImageCache()
await cache.store(data, for: url)     // reaching an actor requires await

@MainActor
@Observable
final class TodoStore {
    var todos: [Todo] = []

    func refresh() async {
        let fetched = await fetchFromServer()   // off the main thread
        todos = fetched                          // back on the main thread to update
    }
}

struct Todo: Sendable { ... }              // usually inferred; you rarely write this

final class Config: Sendable {             // requires every property to be let and Sendable
    let apiKey: String
    init(apiKey: String) { self.apiKey = apiKey }
}

// read a file line by line
for try await line in url.lines {
    print(line)
}

// custom stream
let stream = AsyncStream<Int> { continuation in
    Task {
        for i in 0..<10 {
            continuation.yield(i)
            try? await Task.sleep(for: .seconds(1))
        }
        continuation.finish()
    }
}
for await value in stream { print(value) }

// Package.swift
// swift-tools-version: 6.2
import PackageDescription

let package = Package(
    name: "MyKit",
    platforms: [.iOS(.v26), .macOS(.v26)],   // .v27 becomes available with the Xcode 27 toolchain
    products: [
        .library(name: "MyKit", targets: ["MyKit"])
    ],
    dependencies: [],
    targets: [
        .target(name: "MyKit"),
        .testTarget(name: "MyKitTests", dependencies: ["MyKit"])
    ]
)

swift package init --type library
swift build
swift test
swift run

struct CounterView: View {
    @State private var count = 0

    var body: some View {
        VStack(spacing: 16) {
            Text("Count: \(count)")       // always equals count
                .font(.largeTitle)
            Button("Add one") { count += 1 }  // change data only; the UI updates itself
        }
    }
}

struct MyView: View {
    var body: some View {
        Text("Hello")
    }
}

// text
Text("Title")
    .font(.title)
    .fontWeight(.semibold)
    .foregroundStyle(.secondary)

// images
Image(systemName: "star.fill")        // SF Symbols, 7000+ built-in icons
    .symbolRenderingMode(.multicolor)
Image("myPhoto")                       // from Assets
    .resizable()
    .scaledToFit()

// remote images (HTTP caching by default as of iOS 27)
AsyncImage(url: url) { image in
    image.resizable().scaledToFill()
} placeholder: {
    ProgressView()
}

// buttons
Button("OK") { }
Button("Delete", systemImage: "trash", role: .destructive) { }

// input
@State var text = ""
TextField("Enter something", text: $text)
SecureField("Password", text: $password)
TextEditor(text: $longText)

// selection
Toggle("Enable notifications", isOn: $notificationsEnabled)
Slider(value: $volume, in: 0...1)
Stepper("Quantity: \(count)", value: $count, in: 1...10)
Picker("Size", selection: $size) {
    Text("Small").tag(Size.small)
    Text("Medium").tag(Size.medium)
}
DatePicker("Date", selection: $date, displayedComponents: .date)
ColorPicker("Color", selection: $color)

// status
ProgressView()                          // spinner
ProgressView(value: 0.7)                // progress bar
Label("Favorite", systemImage: "heart")
Link("Visit website", destination: url)
ShareLink(item: url)                    // system share sheet

Text("Hi")
    .padding()              // padding first
    .background(.blue)      // then background → background includes the padding

Text("Hi")
    .background(.blue)      // background first → only as big as the text
    .padding()              // then padding → padding sits outside the background

// size and position
.frame(width: 100, height: 50)
.frame(maxWidth: .infinity)             // take as much as available
.padding(.horizontal, 16)
.offset(x: 10, y: 0)

// appearance
.background(.regularMaterial)           // material (frosted glass) background
.foregroundStyle(.blue)
.clipShape(.rect(cornerRadius: 12))
.overlay { RoundedRectangle(cornerRadius: 12).stroke(.gray) }
.shadow(radius: 4)
.opacity(0.8)

// interaction
.onTapGesture { }
.disabled(isLoading)
.contextMenu { Button("Delete") { } }
.swipeActions { Button("Archive") { } }

// lifecycle
.task { await load() }                  // async work when the view appears
.onAppear { }
.onChange(of: query) { old, new in }

// presentation
.sheet(isPresented: $showSheet) { DetailView() }
.sheet(item: $selectedItem) { item in DetailView(item: item) }
.fullScreenCover(isPresented: $show) { }
.alert("Delete this?", isPresented: $showAlert) {
    Button("Delete", role: .destructive) { }
    Button("Cancel", role: .cancel) { }
}
.confirmationDialog("Choose an action", isPresented: $showDialog) { }
.popover(isPresented: $showPopover) { }

// stacks
VStack(alignment: .leading, spacing: 8) { }    // vertical
HStack { }                                      // horizontal
ZStack(alignment: .topTrailing) { }             // layered

// scrolling
ScrollView { LazyVStack { } }
ScrollView(.horizontal) { LazyHStack { } }

// grids
LazyVGrid(columns: [GridItem(.adaptive(minimum: 100))]) { }

// lists — the workhorse
List(todos) { todo in
    Text(todo.title)
}

// with sections, deletion, and reordering
List {
    Section("Today") {
        ForEach(todos) { todo in
            TodoRow(todo: todo)
        }
        .onDelete { indexSet in delete(at: indexSet) }
        .onMove { from, to in move(from: from, to: to) }
    }
}

// tables (macOS / iPadOS)
Table(people) {
    TableColumn("Name", value: \.name)
    TableColumn("Age") { Text("\($0.age)") }
}

#Preview {
    CounterView()
}

#Preview("Dark mode") {
    CounterView()
        .preferredColorScheme(.dark)
}

#Preview("With data", traits: .sizeThatFitsLayout) {
    TodoRow(todo: .init(title: "Buy milk"))
}

struct ParentView: View {
    @State private var isOn = false          // source of truth lives here

    var body: some View {
        VStack {
            Text(isOn ? "On" : "Off")
            ChildToggle(isOn: $isOn)          // $ produces a Binding
        }
    }
}

struct ChildToggle: View {
    @Binding var isOn: Bool                   // references the parent's state

    var body: some View {
        Toggle("Switch", isOn: $isOn)
    }
}

import Observation

@MainActor
@Observable
final class TodoStore {
    var todos: [Todo] = []
    var isLoading = false

    // properties you don't want observed
    @ObservationIgnored private var cache: [String: Data] = [:]

    func add(_ title: String) {
        todos.append(Todo(title: title))
    }

    func load() async {
        isLoading = true
        defer { isLoading = false }
        todos = await fetchTodos()
    }
}

struct TodoListView: View {
    @State private var store = TodoStore()      // held with @State, not @StateObject

    var body: some View {
        List(store.todos) { todo in
            Text(todo.title)
        }
        .task { await store.load() }
    }
}

struct EditView: View {
    @Bindable var todo: Todo        // Todo is an @Observable class

    var body: some View {
        TextField("Title", text: $todo.title)
    }
}

// 1. define (the iOS 17+ macro form)
extension EnvironmentValues {
    @Entry var todoStore = TodoStore()
}

// 2. inject
@main
struct MyApp: App {
    @State private var store = TodoStore()

    var body: some Scene {
        WindowGroup {
            ContentView()
                .environment(\.todoStore, store)
        }
    }
}

// 3. read
struct DeepChildView: View {
    @Environment(\.todoStore) private var store
    var body: some View { Text("\(store.todos.count)") }
}

ContentView().environment(store)                 // inject
@Environment(TodoStore.self) private var store   // read

@Environment(\.colorScheme) private var colorScheme          // light/dark
@Environment(\.dismiss) private var dismiss                  // close the current screen
@Environment(\.openURL) private var openURL
@Environment(\.horizontalSizeClass) private var sizeClass    // compact/regular layout
@Environment(\.dynamicTypeSize) private var typeSize         // the user's text size setting
@Environment(\.scenePhase) private var scenePhase            // foreground/background
@Environment(\.locale) private var locale

struct SettingsView: View {
    @AppStorage("username") private var username = ""
    @AppStorage("isDarkMode") private var isDarkMode = false
    @AppStorage("fontSize") private var fontSize = 16.0

    var body: some View {
        Form {
            TextField("Username", text: $username)
            Toggle("Dark mode", isOn: $isDarkMode)
        }
    }
}

Used in one view, and simple?
  → @State

Needs to be passed to a child that can modify it?
  → @Binding

Has business logic, shared across views?
  → @Observable class + held with @State + distributed via @Environment

Just a user preference?
  → @AppStorage

Business data that needs to persist?
  → SwiftData (chapter 11)

// NavigationStack — single-column push navigation (the iPhone workhorse)
NavigationStack {
    List(todos) { todo in
        NavigationLink(todo.title, value: todo)
    }
    .navigationTitle("To-do")
    .navigationDestination(for: Todo.self) { todo in
        TodoDetailView(todo: todo)
    }
}

// programmatic navigation: drive it with a path array
@State private var path: [Todo] = []

NavigationStack(path: $path) {
    ...
}
// then path.append(todo) or path.removeAll() to jump / pop

// NavigationSplitView — two or three columns (iPad, Mac)
NavigationSplitView {
    SidebarView()          // sidebar
} content: {
    ListView()             // middle column (optional)
} detail: {
    DetailView()           // detail
}

// TabView — bottom tabs
TabView {
    Tab("Home", systemImage: "house") { HomeView() }
    Tab("Settings", systemImage: "gear") { SettingsView() }
    Tab(role: .search) { SearchView() }     // the search tab gets special styling
}

.toolbar {
    ToolbarItem(placement: .topBarLeading) {
        Button("Cancel") { dismiss() }
    }
    ToolbarItemGroup(placement: .primaryAction) {
        Button("Save") { save() }
        Menu("More") { ... }
    }
}

@State private var query = ""

List(filteredItems) { ... }
    .searchable(text: $query, prompt: "Search to-dos")
    .searchSuggestions {
        ForEach(suggestions) { Text($0).searchCompletion($0) }
    }
    .searchScopes($scope) {
        Text("All").tag(Scope.all)
        Text("Pending").tag(Scope.pending)
    }

// Spacer pushes things apart
HStack {
    Text("left")
    Spacer()
    Text("right")
}

// layout priority
HStack {
    Text("a very long piece of text here").layoutPriority(1)
    Text("short")
}

// fixed size (won't be compressed)
Text("no wrapping").fixedSize()

// ViewThatFits picks the first option that fits
ViewThatFits {
    HStack { A(); B(); C() }      // use this when wide
    VStack { A(); B(); C() }      // use this when narrow
}

// GeometryReader reads available space (avoid when possible — it breaks the negotiation)
GeometryReader { proxy in
    Text("width: \(proxy.size.width)")
}

// Grid — for layouts that need alignment
Grid {
    GridRow { Text("Name"); Text("Jerry") }
    GridRow { Text("City"); Text("Beijing") }
}

// implicit: state changes, transition happens
@State private var isExpanded = false

Rectangle()
    .frame(height: isExpanded ? 200 : 100)
    .animation(.spring, value: isExpanded)     // animate only changes to isExpanded

// explicit
Button("Expand") {
    withAnimation(.spring(duration: 0.4)) {
        isExpanded.toggle()
    }
}

// transitions: how a view appears and disappears
if showDetail {
    DetailView()
        .transition(.move(edge: .bottom).combined(with: .opacity))
}

// matched geometry: morph between two views
@Namespace private var namespace

// view A
Image(...).matchedGeometryEffect(id: "hero", in: namespace)
// view B
Image(...).matchedGeometryEffect(id: "hero", in: namespace)

// navigation transitions (iOS 18+): zoom from a card into a detail screen
NavigationLink { DetailView() } label: { CardView() }
    .matchedTransitionSource(id: item.id, in: namespace)

// phase animator: multi-step animation
Image(systemName: "bell")
    .phaseAnimator([0, -20, 20, 0]) { view, angle in
        view.rotationEffect(.degrees(angle))
    }

// keyframe animator: independent timelines per property
.keyframeAnimator(initialValue: AnimationValues()) { view, value in
    view.scaleEffect(value.scale).offset(y: value.offset)
} keyframes: { _ in
    KeyframeTrack(\.scale) {
        SpringKeyframe(1.2, duration: 0.2)
        SpringKeyframe(1.0, duration: 0.3)
    }
}

// SF Symbols effects
Image(systemName: "heart.fill")
    .symbolEffect(.bounce, value: likeCount)
    .contentTransition(.symbolEffect(.replace))

.onTapGesture(count: 2) { }
.onLongPressGesture { }

@State private var offset = CGSize.zero
.gesture(
    DragGesture()
        .onChanged { offset = $0.translation }
        .onEnded { _ in withAnimation { offset = .zero } }
)

@State private var scale = 1.0
.gesture(MagnifyGesture().onChanged { scale = $0.magnification })

// combining gestures
.gesture(dragGesture.simultaneously(with: magnifyGesture))

// apply the glass effect to a custom view
MyCustomBar()
    .glassEffect(in: .rect(cornerRadius: 20))

// material backgrounds
.background(.regularMaterial)      // also .thin / .thick / .ultraThin / .ultraThick

// button styles
Button("OK") { }.buttonStyle(.glass)
Button("OK") { }.buttonStyle(.borderedProminent)

Image(systemName: "heart.fill")
    .font(.title)
    .symbolRenderingMode(.hierarchical)      // hierarchical rendering
    .foregroundStyle(.red, .pink)            // multicolor
    .symbolVariant(.circle)                  // variants
    .symbolEffect(.pulse)                    // effects

import Charts

struct SalesChart: View {
    let data: [Sale]

    var body: some View {
        Chart(data) { sale in
            BarMark(
                x: .value("Month", sale.month),
                y: .value("Revenue", sale.amount)
            )
            .foregroundStyle(by: .value("Product", sale.product))
        }
        .chartXAxis { AxisMarks(values: .automatic) }
        .chartLegend(position: .bottom)
        .frame(height: 200)
    }
}

import TipKit

struct FavoriteTip: Tip {
    var title: Text { Text("Save this article") }
    var message: Text? { Text("Tap the star to find it later in Favorites") }
    var image: Image? { Image(systemName: "star") }
}

// configure at app launch
try? Tips.configure()

// show it in the UI
Button("Favorite", systemImage: "star") { }
    .popoverTip(FavoriteTip())

struct WebView: UIViewRepresentable {
    let url: URL

    func makeUIView(context: Context) -> WKWebView { WKWebView() }
    func updateUIView(_ view: WKWebView, context: Context) {
        view.load(URLRequest(url: url))
    }
}

Image(systemName: "star.fill")
    .accessibilityLabel("Favorited")
    .accessibilityHint("Double tap to unfavorite")
    .accessibilityAddTraits(.isButton)

// merge a group of elements into one accessible element
HStack { Image(...); Text("Title"); Text("Subtitle") }
    .accessibilityElement(children: .combine)

Text("Hello")                             // localized automatically
Text("^[\(count) item](inflect: true)")   // plural variants, configured in the catalog
String(localized: "Confirm deletion", comment: "Title of the delete confirmation alert")

// formatting (follows the user's region automatically)
Text(date, format: .dateTime.year().month().day())
Text(price, format: .currency(code: "USD"))
Text(bytes, format: .byteCount(style: .file))

import SwiftData

@Model
final class Todo {
    var title: String
    var isDone: Bool
    var createdAt: Date
    var priority: Priority

    // relationships
    @Relationship(deleteRule: .cascade)
    var subtasks: [Subtask] = []

    // not persisted
    @Transient var isEditing = false

    // uniqueness constraint
    #Unique<Todo>([\.title])

    // index for faster queries
    #Index<Todo>([\.createdAt])

    init(title: String, priority: Priority = .normal) {
        self.title = title
        self.isDone = false
        self.createdAt = .now
        self.priority = priority
    }
}

enum Priority: Int, Codable, CaseIterable {
    case low, normal, high
}

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

let container = try ModelContainer(
    for: Todo.self, Subtask.self,
    configurations: ModelConfiguration(
        isStoredInMemoryOnly: false,
        cloudKitDatabase: .automatic      // turn on iCloud sync
    )
)

struct TodoListView: View {
    // simplest: everything
    @Query private var todos: [Todo]

    // sorted
    @Query(sort: \Todo.createdAt, order: .reverse)
    private var recentTodos: [Todo]

    // filter + sort
    @Query(
        filter: #Predicate<Todo> { !$0.isDone },
        sort: [SortDescriptor(\.priority, order: .reverse),
               SortDescriptor(\.createdAt)]
    )
    private var pendingTodos: [Todo]

    var body: some View {
        List(pendingTodos) { todo in
            Text(todo.title)
        }
    }
}

struct SearchableTodoList: View {
    @Query private var todos: [Todo]

    init(searchText: String) {
        _todos = Query(filter: #Predicate<Todo> {
            searchText.isEmpty || $0.title.localizedStandardContains(searchText)
        })
    }

    var body: some View { List(todos) { Text($0.title) } }
}

struct AddTodoView: View {
    @Environment(\.modelContext) private var context
    @State private var title = ""

    var body: some View {
        Form {
            TextField("Title", text: $title)
            Button("Add") {
                context.insert(Todo(title: title))   // insert
                // no manual save() needed; SwiftUI saves automatically
            }
        }
    }
}

// delete
context.delete(todo)

// update: just mutate the property
todo.isDone = true

// manual save (needed outside a SwiftUI context)
try context.save()

// batch delete
try context.delete(model: Todo.self, where: #Predicate { $0.isDone })

@ModelActor
actor TodoImporter {
    func importTodos(from data: Data) throws {
        let items = try JSONDecoder().decode([TodoDTO].self, from: data)
        for item in items {
            modelContext.insert(Todo(title: item.title))
        }
        try modelContext.save()
    }
}

// usage
let importer = TodoImporter(modelContainer: container)
try await importer.importTodos(from: data)

enum TodoSchemaV1: VersionedSchema {
    static var versionIdentifier = Schema.Version(1, 0, 0)
    static var models: [any PersistentModel.Type] { [Todo.self] }
}

enum TodoSchemaV2: VersionedSchema { ... }

enum TodoMigrationPlan: SchemaMigrationPlan {
    static var schemas: [any VersionedSchema.Type] {
        [TodoSchemaV1.self, TodoSchemaV2.self]
    }
    static var stages: [MigrationStage] {
        [.lightweight(fromVersion: TodoSchemaV1.self, toVersion: TodoSchemaV2.self)]
    }
}

UserDefaults.standard.set(true, forKey: "hasSeenOnboarding")
let seen = UserDefaults.standard.bool(forKey: "hasSeenOnboarding")

// sharing data with widgets and extensions requires an App Group
let shared = UserDefaults(suiteName: "group.com.yourname.app")

let docs = URL.documentsDirectory              // user data, backed up
let caches = URL.cachesDirectory                // cache, the system may purge it
let temp = URL.temporaryDirectory               // scratch

let fileURL = docs.appending(path: "notes.json")
try data.write(to: fileURL)
let loaded = try Data(contentsOf: fileURL)

// JSON coding
let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted
encoder.dateEncodingStrategy = .iso8601
let json = try encoder.encode(todos)

import CloudKit

let container = CKContainer.default()
let db = container.publicCloudDatabase

let record = CKRecord(recordType: "Article")
record["title"] = "A title"
try await db.save(record)

let query = CKQuery(recordType: "Article",
                    predicate: NSPredicate(format: "title CONTAINS %@", "Swift"))
let (results, _) = try await db.records(matching: query)

import Security

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

@main
struct MyDocApp: App {
    var body: some Scene {
        DocumentGroup(newDocument: TextDocument()) { file in
            EditorView(document: file.$document)
        }
    }
}

struct APIClient {
    let baseURL = URL(string: "https://api.example.com")!

    func fetch<T: Decodable>(_ path: String, as type: T.Type) async throws -> T {
        let url = baseURL.appending(path: path)
        let (data, response) = try await URLSession.shared.data(from: url)

        guard let http = response as? HTTPURLResponse else {
            throw APIError.invalidResponse
        }
        guard (200..<300).contains(http.statusCode) else {
            throw APIError.server(code: http.statusCode)
        }

        let decoder = JSONDecoder()
        decoder.keyDecodingStrategy = .convertFromSnakeCase
        decoder.dateDecodingStrategy = .iso8601
        return try decoder.decode(T.self, from: data)
    }

    func post<Body: Encodable, T: Decodable>(
        _ path: String, body: Body, as type: T.Type
    ) async throws -> T {
        var request = URLRequest(url: baseURL.appending(path: path))
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.httpBody = try JSONEncoder().encode(body)

        let (data, _) = try await URLSession.shared.data(for: request)
        return try JSONDecoder().decode(T.self, from: data)
    }
}

// download to disk (no memory blow-up)
let (fileURL, _) = try await URLSession.shared.download(from: url)

// upload
let (data, _) = try await URLSession.shared.upload(for: request, from: fileData)

// stream line by line
for try await line in url.lines { print(line) }

// background downloads (continue after the app is backgrounded)
let config = URLSessionConfiguration.background(withIdentifier: "com.app.download")

import Network

let monitor = NWPathMonitor()
monitor.pathUpdateHandler = { path in
    print(path.status == .satisfied ? "online" : "offline")
    print(path.isExpensive ? "cellular" : "Wi-Fi")
}
monitor.start(queue: .global())

import UserNotifications

// request permission
let granted = try await UNUserNotificationCenter.current()
    .requestAuthorization(options: [.alert, .badge, .sound])

// local notification
let content = UNMutableNotificationContent()
content.title = "Time to drink water"
content.body = "It's been two hours"
content.sound = .default

let trigger = UNTimeIntervalNotificationTrigger(timeInterval: 7200, repeats: true)
let request = UNNotificationRequest(identifier: UUID().uuidString,
                                    content: content, trigger: trigger)
try await UNUserNotificationCenter.current().add(request)

import FoundationModels

let session = LanguageModelSession()
let response = try await session.respond(to: "Summarize this in one sentence: \(text)")
print(response.content)

let session = LanguageModelSession(
    instructions: """
    You are an expense-tracking assistant. The user will describe a purchase,
    and you extract the amount, category, and merchant. Keep answers brief.
    """
)

for try await partial in session.streamResponse(to: prompt) {
    displayText = partial.content     // update the UI token by token
}

@Generable
struct Expense {
    @Guide(description: "The amount spent, in dollars")
    let amount: Double

    @Guide(description: "Spending category", .anyOf(["Food", "Transit", "Shopping", "Entertainment", "Other"]))
    let category: String

    @Guide(description: "Merchant name; leave empty if unclear")
    let merchant: String

    @Guide(description: "3-5 tags describing this expense", .count(3...5))
    let tags: [String]
}

let session = LanguageModelSession()
let expense = try await session.respond(
    to: "Spent $5.50 at Starbucks on coffee today",
    generating: Expense.self
).content

print(expense.amount)     // 5.5
print(expense.category)   // "Food"

struct SearchNotesTool: Tool {
    let name = "searchNotes"
    let description = "Search the user's notes for content matching a keyword"

    @Generable
    struct Arguments {
        @Guide(description: "The search keyword")
        let query: String
    }

    func call(arguments: Arguments) async throws -> String {
        let results = await NoteStore.shared.search(arguments.query)
        return results.map(\.title).joined(separator: "\n")
    }
}

let session = LanguageModelSession(
    tools: [SearchNotesTool()],
    instructions: "You can search the user's notes to answer questions."
)
let answer = try await session.respond(to: "What did I write in my design notes last week?")

import AppIntents

struct AddTodoIntent: AppIntent {
    static let title: LocalizedStringResource = "Add to-do"
    static let description = IntentDescription("Add an item to the to-do list")

    @Parameter(title: "Content")
    var text: String

    func perform() async throws -> some IntentResult & ProvidesDialog {
        await TodoStore.shared.add(text)
        return .result(dialog: "Added: \(text)")
    }
}

struct MyAppShortcuts: AppShortcutsProvider {
    static var appShortcuts: [AppShortcut] {
        AppShortcut(
            intent: AddTodoIntent(),
            phrases: [
                "Add a to-do in \(.applicationName)",
                "Note something with \(.applicationName)"
            ],
            shortTitle: "Add to-do",
            systemImageName: "plus.circle"
        )
    }
}

struct TodoEntity: AppEntity {
    let id: UUID
    let title: String

    static let typeDisplayRepresentation: TypeDisplayRepresentation = "To-do"
    var displayRepresentation: DisplayRepresentation { .init(title: "\(title)") }

    static let defaultQuery = TodoQuery()
}

struct TodoQuery: EntityQuery {
    func entities(for ids: [UUID]) async throws -> [TodoEntity] {
        await TodoStore.shared.todos(ids: ids).map(TodoEntity.init)
    }
    func suggestedEntities() async throws -> [TodoEntity] {
        await TodoStore.shared.recent().map(TodoEntity.init)
    }
}

let model = try MyImageClassifier(configuration: MLModelConfiguration())
let output = try await model.prediction(image: pixelBuffer)
print(output.classLabel, output.classLabelProbs)

import Vision

// text recognition (OCR)
let request = RecognizeTextRequest()
let results = try await request.perform(on: image)
for observation in results {
    print(observation.topCandidates(1).first?.string ?? "")
}

import MapKit
import CoreLocation

// maps (SwiftUI-native)
Map {
    Marker("Office", coordinate: officeCoordinate)
    Annotation("Home", coordinate: homeCoordinate) {
        Image(systemName: "house.fill")
    }
    MapPolyline(coordinates: route)
        .stroke(.blue, lineWidth: 4)
}
.mapStyle(.standard(elevation: .realistic))
.mapControls { MapUserLocationButton(); MapCompass() }

// location
let manager = CLLocationManager()
manager.requestWhenInUseAuthorization()

// place search
let request = MKLocalSearch.Request()
request.naturalLanguageQuery = "coffee"
let response = try await MKLocalSearch(request: request).start()

import HealthKit

let store = HKHealthStore()
try await store.requestAuthorization(toShare: [], read: [
    HKQuantityType(.stepCount), HKQuantityType(.heartRate)
])

let descriptor = HKSampleQueryDescriptor(
    predicates: [.quantitySample(type: HKQuantityType(.stepCount))],
    sortDescriptors: [SortDescriptor(\.startDate, order: .reverse)],
    limit: 100
)
let samples = try await descriptor.result(for: store)

import WeatherKit

let weather = try await WeatherService.shared.weather(for: location)
print(weather.currentWeather.temperature)
print(weather.dailyForecast.forecast.first?.highTemperature ?? "")

// picking photos
@State private var item: PhotosPickerItem?
PhotosPicker("Choose a photo", selection: $item, matching: .images)
    .onChange(of: item) { _, new in
        Task {
            if let data = try? await new?.loadTransferable(type: Data.self) {
                image = UIImage(data: data)
            }
        }
    }

// video playback
VideoPlayer(player: AVPlayer(url: videoURL))

// Sign in with Apple
SignInWithAppleButton(.signIn) { request in
    request.requestedScopes = [.fullName, .email]
} onCompletion: { result in
    // handle the result
}
.signInWithAppleButtonStyle(.black)

// biometrics
import LocalAuthentication
let context = LAContext()
let ok = try await context.evaluatePolicy(
    .deviceOwnerAuthenticationWithBiometrics,
    localizedReason: "Unlock your notes"
)

import WidgetKit
import SwiftUI

struct TodoEntry: TimelineEntry {
    let date: Date
    let pendingCount: Int
}

struct TodoProvider: TimelineProvider {
    func placeholder(in context: Context) -> TodoEntry {
        TodoEntry(date: .now, pendingCount: 3)
    }
    func getSnapshot(in context: Context, completion: @escaping (TodoEntry) -> Void) {
        completion(TodoEntry(date: .now, pendingCount: currentCount()))
    }
    func getTimeline(in context: Context, completion: @escaping (Timeline<TodoEntry>) -> Void) {
        let entry = TodoEntry(date: .now, pendingCount: currentCount())
        completion(Timeline(entries: [entry], policy: .after(.now.addingTimeInterval(3600))))
    }
}

struct TodoWidgetView: View {
    let entry: TodoEntry
    var body: some View {
        VStack {
            Text("\(entry.pendingCount)").font(.largeTitle.bold())
            Text("To-do").font(.caption)
        }
        .containerBackground(.fill.tertiary, for: .widget)
    }
}

@main
struct TodoWidget: Widget {
    var body: some WidgetConfiguration {
        StaticConfiguration(kind: "TodoWidget", provider: TodoProvider()) { entry in
            TodoWidgetView(entry: entry)
        }
        .configurationDisplayName("To-do count")
        .supportedFamilies([.systemSmall, .systemMedium, .accessoryCircular])
    }
}

struct ToggleTodoIntent: AppIntent {
    static let title: LocalizedStringResource = "Toggle completion"
    @Parameter var todoID: String

    func perform() async throws -> some IntentResult {
        await TodoStore.shared.toggle(id: todoID)
        return .result()
    }
}

// in the widget view
Button(intent: ToggleTodoIntent(todoID: todo.id)) {
    Image(systemName: todo.isDone ? "checkmark.circle.fill" : "circle")
}

import ActivityKit

struct DeliveryAttributes: ActivityAttributes {
    struct ContentState: Codable, Hashable {
        var status: String
        var estimatedMinutes: Int
    }
    let orderNumber: String
}

// start
let activity = try Activity.request(
    attributes: DeliveryAttributes(orderNumber: "12345"),
    content: .init(state: .init(status: "Out for delivery", estimatedMinutes: 20), staleDate: nil)
)

// update
await activity.update(.init(state: .init(status: "Arriving soon", estimatedMinutes: 3), staleDate: nil))

// end
await activity.end(nil, dismissalPolicy: .immediate)

struct QuickAddControl: ControlWidget {
    var body: some ControlWidgetConfiguration {
        StaticControlConfiguration(kind: "QuickAdd") {
            ControlWidgetButton(action: AddTodoIntent()) {
                Label("Quick add", systemImage: "plus")
            }
        }
    }
}

// shapes
Circle()
RoundedRectangle(cornerRadius: 12)
Capsule()

// custom shapes
struct Triangle: Shape {
    func path(in rect: CGRect) -> Path {
        var p = Path()
        p.move(to: CGPoint(x: rect.midX, y: rect.minY))
        p.addLine(to: CGPoint(x: rect.maxX, y: rect.maxY))
        p.addLine(to: CGPoint(x: rect.minX, y: rect.maxY))
        p.closeSubpath()
        return p
    }
}

// Canvas — imperative, high-performance drawing (use it for lots of primitives)
Canvas { context, size in
    for i in 0..<1000 {
        context.fill(Path(ellipseIn: randomRect(in: size)), with: .color(.blue))
    }
}

// gradients and effects
.background(LinearGradient(colors: [.blue, .purple], startPoint: .top, endPoint: .bottom))
MeshGradient(width: 3, height: 3, points: [...], colors: [...])
.blur(radius: 8)
.visualEffect { content, proxy in
    content.scaleEffect(proxy.frame(in: .global).minY / 1000)
}

// Shaders.metal
[[ stitchable ]] half4 wave(float2 position, half4 color, float time) {
    // ...
}

// SwiftUI
Image("photo")
    .colorEffect(ShaderLibrary.wave(.float(time)))

import RealityKit

struct ImmersiveView: View {
    var body: some View {
        RealityView { content in
            // load a model
            if let robot = try? await Entity(named: "Robot") {
                robot.position = [0, 1, -2]
                robot.components.set(InputTargetComponent())
                robot.generateCollisionShapes(recursive: true)
                content.add(robot)
            }

            // create procedurally
            let sphere = ModelEntity(
                mesh: .generateSphere(radius: 0.1),
                materials: [SimpleMaterial(color: .blue, isMetallic: true)]
            )
            content.add(sphere)
        } update: { content in
            // respond to state changes
        }
        .gesture(
            TapGesture().targetedToAnyEntity().onEnded { value in
                value.entity.position.y += 0.1
            }
        )
    }
}

@main
struct SpatialApp: App {
    var body: some Scene {
        // 1. Window — flat UI, similar to an iPad app
        WindowGroup { ContentView() }

        // 2. Volume — a 3D box with depth, coexisting with other apps in the Shared Space
        WindowGroup(id: "volume") {
            ModelView()
        }
        .windowStyle(.volumetric)
        .defaultSize(width: 0.5, height: 0.5, depth: 0.5, in: .meters)

        // 3. Immersive Space — takes over the whole environment
        ImmersiveSpace(id: "immersive") {
            ImmersiveView()
        }
        .immersionStyle(selection: $style, in: .mixed, .progressive, .full)
    }
}

#if os(iOS)
    .navigationBarTitleDisplayMode(.inline)
#elseif os(macOS)
    .frame(minWidth: 600, minHeight: 400)
#endif

// better: branch on size class rather than platform
@Environment(\.horizontalSizeClass) private var sizeClass
if sizeClass == .compact { VStack { ... } } else { HStack { ... } }

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup { ContentView() }
            .commands {                       // menu bar
                CommandGroup(after: .newItem) {
                    Button("Import…") { }.keyboardShortcut("i", modifiers: .command)
                }
            }

        Settings { SettingsView() }           // preferences window

        MenuBarExtra("Status", systemImage: "star") {   // menu bar item
            StatusView()
        }
    }
}

import StoreKit

@MainActor
@Observable
final class Store {
    private(set) var products: [Product] = []
    private(set) var purchasedIDs: Set<String> = []

    private let productIDs = ["com.app.pro.monthly", "com.app.pro.yearly", "com.app.lifetime"]
    private var updateTask: Task<Void, Never>?

    init() {
        updateTask = Task { await observeTransactions() }
    }

    func loadProducts() async {
        products = (try? await Product.products(for: productIDs)) ?? []
    }

    func purchase(_ product: Product) async throws {
        let result = try await product.purchase()
        switch result {
        case .success(let verification):
            let transaction = try checkVerified(verification)
            await updateEntitlements()
            await transaction.finish()
        case .userCancelled, .pending:
            break
        @unknown default:
            break
        }
    }

    func restore() async throws {
        try await AppStore.sync()
        await updateEntitlements()
    }

    private func updateEntitlements() async {
        var ids: Set<String> = []
        for await result in Transaction.currentEntitlements {
            if let t = try? checkVerified(result) {
                ids.insert(t.productID)
            }
        }
        purchasedIDs = ids
    }

    // watch for transactions that happen elsewhere (Family Sharing, refunds, renewals)
    private func observeTransactions() async {
        for await result in Transaction.updates {
            if let t = try? checkVerified(result) {
                await updateEntitlements()
                await t.finish()
            }
        }
    }

    private func checkVerified<T>(_ result: VerificationResult<T>) throws -> T {
        switch result {
        case .verified(let safe): return safe
        case .unverified: throw StoreError.failedVerification
        }
    }
}

enum StoreError: Error { case failedVerification }

// subscription page (Apple's standard layout, localized, handles purchase flow)
SubscriptionStoreView(groupID: "YOUR_GROUP_ID") {
    VStack {
        Image(systemName: "star.circle.fill").font(.system(size: 60))
        Text("Upgrade to Pro").font(.largeTitle.bold())
    }
}
.storeButton(.visible, for: .restorePurchases)
.subscriptionStorePolicyDestination(url: privacyURL, for: .privacyPolicy)

// a single product
ProductView(id: "com.app.lifetime")

// a product list
StoreView(ids: productIDs)

import Testing
@testable import MyApp

@Test func addingATodoIncreasesTheCount() {
    let store = TodoStore()
    store.add("Buy milk")
    #expect(store.todos.count == 1)
    #expect(store.todos.first?.title == "Buy milk")
}

@Test("Empty titles should be rejected")
func rejectsEmptyTitle() throws {
    let store = TodoStore()
    #expect(throws: ValidationError.self) {
        try store.addValidated("")
    }
}

// parameterized tests: one test, many inputs
@Test(arguments: [("", false), ("a", true), (String(repeating: "x", count: 200), false)])
func titleValidation(input: String, expected: Bool) {
    #expect(Todo.isValidTitle(input) == expected)
}

// suites and tags
@Suite("To-do storage")
struct TodoStoreTests {
    @Test(.tags(.critical)) func persistence() async throws { ... }
}

1. Create an app record in App Store Connect (Bundle ID must match Xcode)
2. Prepare assets: icon, screenshots (all sizes), description, keywords, privacy labels, age rating
3. Xcode: Product → Archive → Distribute App → App Store Connect
4. Assign the build to TestFlight in App Store Connect
5. TestFlight beta (up to 100 internal, 10,000 external testers; external requires a light review)
6. Collect feedback, fix, iterate
7. Submit for review (typically 24–48 hours)
8. Release manually or automatically once approved