Expansions

struct Pet {
    @ClampedToTen var food: Int
}

struct HandWrittenPet {
    private var _food = ClampedToTen()        // the hidden storage: the wrapper itself

    var food: Int {
        get {
            _food.wrappedValue
        }
        set {
            _food.wrappedValue = newValue
        }
    }
}

import SwiftUI

struct Counter: View {
    @State private var count = 0
    @Binding var name: String

    var body: some View {
        Text("\(name): \(count)")
    }
}

struct Counter: View {
    @State private var count = 0
    {
        get {
            __count.wrappedValue
        }
        nonmutating set {
            __count.wrappedValue = newValue
        }
    }

    private var __count = SwiftUICore.State._makeStorage({ 0 })

    @SwiftUICore._StateProjectedValue
    private var $count = SwiftUICore.State(initialValue: 0).projectedValue
    {
        get {
            __count.projectedValue
        }
    }

    // …and `_count`, and a private static that holds the starting value.

    @Binding var name: String

    var body: some View {
        Text("\(name): \(count)")
    }
}

import SwiftUI

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

    var body: some View {
        Child(name: $name)
    }
}

struct Child: View {
    @Binding var name: String

    var body: some View {
        Button("Shout") {
            name = name.uppercased()
        }
    }
}

struct Ref<Value> {
    let get: () -> Value
    let set: (Value) -> Void

    var value: Value {
        get {
            get()
        }
        nonmutating set {
            set(newValue)
        }
    }
}

// $name is a Ref: a getter and a setter, passed together. Child writes through it.
let name = Ref(get: { parent.name }, set: { parent.name = $0 })
name.value = name.value.uppercased()

import SwiftUI

struct Settings: View {
    @AppStorage("petName") private var petName = "Pip"

    var body: some View {
        Text(petName)
    }
}

import Foundation

@propertyWrapper
struct Stored<Value> {
    private let key: String
    private let defaultValue: Value

    init(wrappedValue: Value, _ key: String) {
        self.key = key
        self.defaultValue = wrappedValue
    }

    var wrappedValue: Value {
        get {
            UserDefaults.standard.object(forKey: key) as? Value ?? defaultValue
        }
        nonmutating set {
            UserDefaults.standard.set(newValue, forKey: key)
        }
    }
}

import Observation

/// What the feeder has seen today. On the main actor: the screen reads it.
@MainActor
@Observable
final class Sightings {
    var robins = 0
    var sparrows = 0
}

@MainActor
@Observable
final class Sightings {
    @ObservationIgnored private let _$observationRegistrar = Observation.ObservationRegistrar()

    internal nonisolated func access<Member>(
      keyPath: KeyPath<Sightings, Member>
    ) {
      _$observationRegistrar.access(self, keyPath: keyPath)
    }

    internal nonisolated func withMutation<Member, MutationResult>(
      keyPath: KeyPath<Sightings, Member>,
      _ mutation: () throws -> MutationResult
    ) rethrows -> MutationResult {
      try _$observationRegistrar.withMutation(of: self, keyPath: keyPath, mutation)
    }

    // …and four private overloads of shouldNotifyObservers, which the setter calls.

    @ObservationIgnored
    private var _robins = 0

    @ObservationTracked
    var robins = 0
    {
        @storageRestrictions(initializes: _robins)
        init(initialValue) {
            _robins = initialValue
        }
        get {
            access(keyPath: \.robins)
            return _robins
        }
        set {
            guard shouldNotifyObservers(_robins, newValue) else {
                _robins = newValue
                return
            }
            withMutation(keyPath: \.robins) {
                _robins = newValue
            }
        }
        _modify {
            access(keyPath: \.robins)
            _$observationRegistrar.willSet(self, keyPath: \.robins)
            defer {
                _$observationRegistrar.didSet(self, keyPath: \.robins)
            }
            yield &_robins
        }
    }

    // `sparrows` gets the same storage and accessors.
}

extension Sightings: nonisolated Observation.Observable {
}

let card = stack {
    Line("Seattle")
    Line("5 nights")
}

@resultBuilder
enum WidgetBuilder {
    static func buildPartialBlock<W: Widget>(first: W) -> W {
        first
    }

    static func buildPartialBlock<A: Widget, B: Widget>(accumulated: A, next: B) -> Column<A, B> {
        Column(accumulated, next)
    }
}

// the block, as the compiler rewrites it: one call on the builder per statement
let card = WidgetBuilder.buildPartialBlock(
    accumulated: WidgetBuilder.buildPartialBlock(first: Line("Seattle")),
    next: Line("5 nights")
)

/// Ada flies to a flower and comes back with what she found. The flight is an `await`.
/// `@MainActor`: she leaves from the queen's actor — on purpose, to see what the wait does to it.
@MainActor func fly() async throws -> Int {
    print("Ada leaves from \(whereAmI())")
    let (data, _) = try await URLSession.shared.data(from: meadow)
    print("Ada is back on \(whereAmI())")
    return data.count
}

import Foundation

// fly(), as the compiler builds it: two ordinary functions, and the request's completion handler between them.
// You never write this. It is what `await` means.
@MainActor func flyFirstHalf(then: @escaping @Sendable (Int) -> Void) {
    // everything before the await
    print("Ada leaves from \(whereAmI())")
    // the wait. The closure runs when the data has arrived, on some other thread —
    // so it hops back to the actor the first half was on, and runs the second half there
    URLSession.shared.dataTask(with: meadow) { data, _, _ in
        Task { @MainActor in
            flySecondHalf(data ?? Data(), then: then)
        }
    }.resume()
    // and the first half returns here: the thread is free
}

@MainActor func flySecondHalf(_ data: Data, then: (Int) -> Void) {
    // everything after the await
    print("Ada is back on \(whereAmI())")
    then(data.count)
}

/// Counting every grain of pollen in the meadow: a long computation, with nothing to wait for —
/// now on the shared thread pool, so that the queen is free while it runs.
@concurrent func countPollen() async -> Int {
    var grains = 0
    for i in 0..<60_000_000 where sin(Double(i)) > 0.999 {
        grains += 1
    }
    print("counted on \(whereAmI())")
    return grains
}

import Foundation

// @concurrent, written out as the Swift you could write before it existed: hand the body to the shared pool,
// and wait for it, where you are. The queen is free while you wait.
nonisolated(nonsending) func countPollenByHand() async -> Int {
    // a new task, on the shared pool, on no actor — and .value: suspend here until it is done
    await Task.detached {
        var grains = 0
        for i in 0..<60_000_000 where sin(Double(i)) > 0.999 {
            grains += 1
        }
        print("counted on \(whereAmI())")
        return grains
    }.value
}

func f() async -> Int {  // stands for anything you could call
    1
}

func t() async {
    async let x = f()
}

%0 = metatype $@thick MainActor.Type
// function_ref static MainActor.shared.getter
%1 = function_ref @$sScM6sharedScMvgZ : $@convention(method) (@thick MainActor.Type) -> @owned MainActor
%2 = apply %1(%0) : $@convention(method) (@thick MainActor.Type) -> @owned MainActor
hop_to_executor %2

%4 = alloc_stack $Int
%5 = address_to_pointer %4 to $Builtin.RawPointer
%6 = enum $Optional<Builtin.RawPointer>, #Optional.none!enumelt
// function_ref implicit closure #1 in t()
%7 = function_ref @$s7program1tyyYaFSiyYaYbcfu_ : $@convention(thin) @Sendable @async @substituted <τ_0_0> () -> (@out τ_0_0, @error any Error) for <Int>
%8 = convert_function %7 to $@convention(thin) @async @substituted <τ_0_0> () -> (@out τ_0_0, @error any Error) for <Int>
%9 = thin_to_thick_function %8 to $@noescape @async @callee_guaranteed @substituted <τ_0_0> () -> (@out τ_0_0, @error any Error) for <Int>
%10 = builtin "startAsyncLetWithLocalBuffer"<Int>(%6, %9, %5) : $Builtin.RawPointer

%2 = enum $Optional<any Actor>, #Optional.none!enumelt
// function_ref f()
%3 = function_ref @$s7program1fSiyYaF : $@convention(thin) @async () -> Int
%4 = apply %3() : $@convention(thin) @async () -> Int
hop_to_executor %2
store %4 to %0
%7 = tuple ()
return %7

%11 = builtin "finishAsyncLet"(%10, %5) : $()
hop_to_executor %2
strong_release %2
%14 = builtin "endAsyncLetLifetime"(%10) : $()
dealloc_stack %4
%16 = tuple ()
return %16

extension Jar {
    /// A slow pour: look at the jar, go and get the honey, come back and put one drop on top of what you saw.
    func pourSlowly() async {
        let seen = drops
        try? await Task.sleep(for: .milliseconds(10))
        drops = seen + 1
    }
}

// pourSlowly(), as the compiler builds it: the method is cut at the await into two jobs for the jar.
// Between them the jar is free — so another bee's first job can run, and see the same `drops` you saw.
extension Jar {
    func pourSlowlyByHand() async {
        let seen = startPour()                           // job 1, in the jar
        try? await Task.sleep(for: .milliseconds(10))    // not in the jar: anyone may pour now
        finishPour(seen)                                 // job 2, in the jar again
    }

    func startPour() -> Int {
        drops
    }

    func finishPour(_ seen: Int) {
        drops = seen + 1
    }
}

import Foundation

/// The actor this call is on: "MainActor", the name of an actor of yours, or "no actor". From lesson 1.
func whereAmI(_ isolation: isolated (any Actor)? = #isolation) -> String {
    isolation.map { "\(type(of: $0))" } ?? "no actor"
}

/// Whether this code is on the main thread. Only a synchronous function may ask — in `async` code the answer can
/// change at every `await`, and Swift 6 refuses the question there. On no actor: it answers for whoever calls it.
func onMainThread() -> Bool {
    Thread.isMainThread
}

// #isolation, written out: the compiler puts the caller's own actor into the argument.

/// whereAmI(), called from a view or any main-actor code.
@MainActor func whereIsHereByHand() -> String {
    whereAmI(MainActor.shared)
}

/// whereAmI(), called from a @concurrent function, as whereIsThePool() does.
@concurrent func whereIsThePoolByHand() async -> String {
    whereAmI(nil)
}

extension Jar {
    /// whereAmI(), called from inside one of the jar's methods, as whereIsTheJar() does.
    func whereIsTheJarByHand() -> String {
        whereAmI(self)
    }
}

import SwiftUI

struct Watcher: View {
    var body: some View {
        Text("watching")
            .task {
                await watch("the .task modifier")
            }
    }
}

import SwiftUI

struct WatcherByHand: View {
    @State private var watching: Task<Void, Never>?

    var body: some View {
        Text("watching, by hand")
            .onAppear {
                watching = Task {
                    await watch("onAppear and onDisappear")
                }
            }
            .onDisappear {
                watching?.cancel()
            }
    }
}

Task {
    print("Task { }: \(whereAmI())")
}

// Task { } is a new task on the shared pool that first hops to the actor of the code that made it —
// here the main actor — and keeps that code's priority.
Task.detached(priority: Task.currentPriority) {
    await MainActor.run {
        print("Task { } by hand: \(whereAmI())")
    }
}

@concurrent func fromThePool() async {
    await report()
}

@concurrent func fromThePoolByHand() async {
    await MainActor.run {
        report()
    }
}