Track a parcel with async and await

/// The courier's records: the depot that holds each parcel, and how many hours away each depot is. Constants of plain
/// values: Swift 6 lets any code, on any thread, read them.
let depots = ["ZX-42": "Tacoma", "QF-7": "Spokane"]
let hoursAway = ["Tacoma": 3, "Spokane": 6]

/// 2016: ask where a parcel is. The answer comes later, to the closure — after a wait that stands in for the network.
func locate(_ parcel: String, completion: @escaping (String?) -> Void) {
    DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
        completion(depots[parcel])
    }
}

/// 2016: ask how far away a depot is.
func hours(from depot: String, completion: @escaping (Int) -> Void) {
    DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
        completion(hoursAway[depot] ?? 0)
    }
}

/// 2016: ask where a parcel is. The answer comes later, to the closure — after a wait that stands in for the network.func locate(_ parcel: String, completion: @escaping (String?) -> Void) {/// `@MainActor` on the closure's type: the closure is called on the main actor. The main queue's convention, written/// down, so that the compiler can check it.func locate(_ parcel: String, completion: @escaping @MainActor (String?) -> Void) {    DispatchQueue.main.asyncAfter(deadline: .now() + 2) {        completion(depots[parcel])    }}/// 2016: ask how far away a depot is.func hours(from depot: String, completion: @escaping (Int) -> Void) {/// 2016: ask how far away a depot is. The answer, too, comes back on the main actor.func hours(from depot: String, completion: @escaping @MainActor (Int) -> Void) {    DispatchQueue.main.asyncAfter(deadline: .now() + 1) {        completion(hoursAway[depot] ?? 0)    }}

/// 2016: ask where a parcel is. The answer comes later, to the closure — after a wait that stands in for the network.
/// `@MainActor` on the closure's type: the closure is called on the main actor. The main queue's convention, written
/// down, so that the compiler can check it.
func locate(_ parcel: String, completion: @escaping @MainActor (String?) -> Void) {
    DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
        completion(depots[parcel])
    }
}

/// 2016: ask how far away a depot is. The answer, too, comes back on the main actor.
func hours(from depot: String, completion: @escaping @MainActor (Int) -> Void) {
    DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
        completion(hoursAway[depot] ?? 0)
    }
}

@MainActor    // the app calls run() on the main actor; each Task { } it starts begins there toofunc run() {    print("Hello from run()")    print("Asking the courier about ZX-42.")    locate("ZX-42") { depot in        guard let depot else {            print("No parcel ZX-42.")            return        }        hours(from: depot) { away in            print("ZX-42 is at the \(depot) depot, \(away) hours away.")        }    }    print("run() is done; the answer comes later.")}

@MainActor    // the app calls run() on the main actor; each Task { } it starts begins there too
func run() {
    print("Asking the courier about ZX-42.")
    locate("ZX-42") { depot in
        guard let depot else {
            print("No parcel ZX-42.")
            return
        }
        hours(from: depot) { away in
            print("ZX-42 is at the \(depot) depot, \(away) hours away.")
        }
    }
    print("run() is done; the answer comes later.")
}

/// 2016: ask where a parcel is. The answer comes later, to the closure — after a wait that stands in for the network./// `@MainActor` on the closure's type: the closure is called on the main actor. The main queue's convention, written/// down, so that the compiler can check it.func locate(_ parcel: String, completion: @escaping @MainActor (String?) -> Void) {    DispatchQueue.main.asyncAfter(deadline: .now() + 2) {        completion(depots[parcel])    }/// Ask where a parcel is. The function says that it can wait — `async` — and returns the answer when it has it./// `nonisolated(nonsending)`: it runs on whatever actor calls it. It only waits, so it has no reason to move.nonisolated(nonsending) func locate(_ parcel: String) async -> String? {    try? await Task.sleep(for: .seconds(2))     // stands in for the network    return depots[parcel]}/// 2016: ask how far away a depot is. The answer, too, comes back on the main actor.func hours(from depot: String, completion: @escaping @MainActor (Int) -> Void) {    DispatchQueue.main.asyncAfter(deadline: .now() + 1) {        completion(hoursAway[depot] ?? 0)    }/// Ask how far away a depot is. On its caller's actor, like `locate`.nonisolated(nonsending) func hours(from depot: String) async -> Int {    try? await Task.sleep(for: .seconds(1))    return hoursAway[depot] ?? 0}

/// Ask where a parcel is. The function says that it can wait — `async` — and returns the answer when it has it.
/// `nonisolated(nonsending)`: it runs on whatever actor calls it. It only waits, so it has no reason to move.
nonisolated(nonsending) func locate(_ parcel: String) async -> String? {
    try? await Task.sleep(for: .seconds(2))     // stands in for the network
    return depots[parcel]
}

/// Ask how far away a depot is. On its caller's actor, like `locate`.
nonisolated(nonsending) func hours(from depot: String) async -> Int {
    try? await Task.sleep(for: .seconds(1))
    return hoursAway[depot] ?? 0
}

@MainActor    // the app calls run() on the main actor; each Task { } it starts begins there toofunc run() {    print("Asking the courier about ZX-42.")    locate("ZX-42") { depot in        guard let depot else {    // the way in from code that cannot wait; it starts on run()'s actor    Task {        guard let depot = await locate("ZX-42") else {            print("No parcel ZX-42.")            return        }        hours(from: depot) { away in            print("ZX-42 is at the \(depot) depot, \(away) hours away.")        }        let away = await hours(from: depot)        print("ZX-42 is at the \(depot) depot, \(away) hours away.")    }    print("run() is done; the answer comes later.")}

@MainActor    // the app calls run() on the main actor; each Task { } it starts begins there too
func run() {
    print("Asking the courier about ZX-42.")
    // the way in from code that cannot wait; it starts on run()'s actor
    Task {
        guard let depot = await locate("ZX-42") else {
            print("No parcel ZX-42.")
            return
        }
        let away = await hours(from: depot)
        print("ZX-42 is at the \(depot) depot, \(away) hours away.")
    }
    print("run() is done; the answer comes later.")
}

@MainActor    // the app calls run() on the main actor; each Task { } it starts begins there toofunc run() {    print("Asking the courier about ZX-42.")    // the way in from code that cannot wait; it starts on run()'s actor    // on the main actor, like run() — the actor that moves the clock    Task {        guard let depot = await locate("ZX-42") else {            print("No parcel ZX-42.")            return        let before = WallClock.shared.ticks        let depot = await locate("ZX-42")        print("While the courier answered (\(depot ?? "?")), the clock ticked \(WallClock.shared.ticks - before) times.")        let again = WallClock.shared.ticks        let clock = ContinuousClock()        let end = clock.now + .seconds(2)        var steps = 0        while clock.now < end {        // two seconds of arithmetic: nothing to wait for            steps += 1        }        let away = await hours(from: depot)        print("ZX-42 is at the \(depot) depot, \(away) hours away.")        print("While we computed (\(steps) steps), the clock ticked \(WallClock.shared.ticks - again) times.")    }    print("run() is done; the answer comes later.")}

@MainActor    // the app calls run() on the main actor; each Task { } it starts begins there too
func run() {
    // on the main actor, like run() — the actor that moves the clock
    Task {
        let before = WallClock.shared.ticks
        let depot = await locate("ZX-42")
        print("While the courier answered (\(depot ?? "?")), the clock ticked \(WallClock.shared.ticks - before) times.")

        let again = WallClock.shared.ticks
        let clock = ContinuousClock()
        let end = clock.now + .seconds(2)
        var steps = 0
        while clock.now < end {        // two seconds of arithmetic: nothing to wait for
            steps += 1
        }
        print("While we computed (\(steps) steps), the clock ticked \(WallClock.shared.ticks - again) times.")
    }
}

@MainActor    // the app calls run() on the main actor; each Task { } it starts begins there toofunc run() {    // on the main actor, like run() — the actor that moves the clock    Task {        let before = WallClock.shared.ticks        let depot = await locate("ZX-42")        print("While the courier answered (\(depot ?? "?")), the clock ticked \(WallClock.shared.ticks - before) times.")        let again = WallClock.shared.ticks        let clock = ContinuousClock()        let end = clock.now + .seconds(2)        var steps = 0        while clock.now < end {        // two seconds of arithmetic: nothing to wait for            steps += 1        }        print("While we computed (\(steps) steps), the clock ticked \(WallClock.shared.ticks - again) times.")    }    let depot = await locate("QF-7")    print(depot ?? "?")}

@MainActor    // the app calls run() on the main actor; each Task { } it starts begins there too
func run() {
    let depot = await locate("QF-7")
    print(depot ?? "?")
}

@MainActor    // the app calls run() on the main actor; each Task { } it starts begins there toofunc run() {    let depot = await locate("QF-7")    print(depot ?? "?")    print("1. Before the task.")    // queued on the main actor, which run() is still using    Task {        print("3. Inside the task, before the wait.")        let depot = await locate("QF-7")        print("4. Inside the task, after the wait: \(depot ?? "?").")    }    print("2. After the task: run() returns here.")}

@MainActor    // the app calls run() on the main actor; each Task { } it starts begins there too
func run() {
    print("1. Before the task.")
    // queued on the main actor, which run() is still using
    Task {
        print("3. Inside the task, before the wait.")
        let depot = await locate("QF-7")
        print("4. Inside the task, after the wait: \(depot ?? "?").")
    }
    print("2. After the task: run() returns here.")
}

/// A duration, as "4.1 s".
func seconds(_ took: Duration) -> String {
    (took / .seconds(1)).formatted(.number.precision(.fractionLength(1))) + " s"
}

@MainActor    // the app calls run() on the main actor; each Task { } it starts begins there toofunc run() {    print("1. Before the task.")    // queued on the main actor, which run() is still using    Task {        print("3. Inside the task, before the wait.")        let depot = await locate("QF-7")        print("4. Inside the task, after the wait: \(depot ?? "?").")        let clock = ContinuousClock()        let oneAfterTheOther = await clock.measure {            let a = await locate("ZX-42")            let b = await locate("QF-7")            print(a ?? "?", b ?? "?")        }        print("One after the other:", seconds(oneAfterTheOther))        let together = await clock.measure {            async let a = locate("ZX-42")       // a child task, started here            async let b = locate("QF-7")        // and another, at once            print(await a ?? "?", await b ?? "?")        }        print("Together, with async let:", seconds(together))    }    print("2. After the task: run() returns here.")}

@MainActor    // the app calls run() on the main actor; each Task { } it starts begins there too
func run() {
    Task {
        let clock = ContinuousClock()

        let oneAfterTheOther = await clock.measure {
            let a = await locate("ZX-42")
            let b = await locate("QF-7")
            print(a ?? "?", b ?? "?")
        }
        print("One after the other:", seconds(oneAfterTheOther))

        let together = await clock.measure {
            async let a = locate("ZX-42")       // a child task, started here
            async let b = locate("QF-7")        // and another, at once
            print(await a ?? "?", await b ?? "?")
        }
        print("Together, with async let:", seconds(together))
    }
}

/// What can go wrong with the courier. An `Error` must be `Sendable` — it may be thrown on one side of an `await` and
/// caught on the other — and an enum of strings is.
enum CourierError: Error {
    case unknownParcel(String)
}

/// Ask where a parcel is. The function says that it can wait — `async` — and returns the answer when it has it./// `nonisolated(nonsending)`: it runs on whatever actor calls it. It only waits, so it has no reason to move.nonisolated(nonsending) func locate(_ parcel: String) async -> String? {    try? await Task.sleep(for: .seconds(2))     // stands in for the network    return depots[parcel]/// Ask where a parcel is. The courier has records only for the parcels it carries: for any other, it throws. On its/// caller's actor, as before.nonisolated(nonsending) func locate(_ parcel: String) async throws -> String {    // stands in for the network — and throws if nobody is waiting any more    try await Task.sleep(for: .seconds(2))    guard let depot = depots[parcel] else {        throw CourierError.unknownParcel(parcel)    }    return depot}/// Ask how far away a depot is. On its caller's actor, like `locate`.nonisolated(nonsending) func hours(from depot: String) async -> Int {    try? await Task.sleep(for: .seconds(1))    return hoursAway[depot] ?? 0}

/// Ask where a parcel is. The courier has records only for the parcels it carries: for any other, it throws. On its
/// caller's actor, as before.
nonisolated(nonsending) func locate(_ parcel: String) async throws -> String {
    // stands in for the network — and throws if nobody is waiting any more
    try await Task.sleep(for: .seconds(2))
    guard let depot = depots[parcel] else {
        throw CourierError.unknownParcel(parcel)
    }
    return depot
}

/// Ask how far away a depot is. On its caller's actor, like `locate`.
nonisolated(nonsending) func hours(from depot: String) async -> Int {
    try? await Task.sleep(for: .seconds(1))
    return hoursAway[depot] ?? 0
}

@MainActor    // the app calls run() on the main actor; each Task { } it starts begins there toofunc run() {    Task {        let clock = ContinuousClock()        do {            let depot = try await locate("ZX-42")            let away = await hours(from: depot)            print("ZX-42 is at the \(depot) depot, \(away) hours away.")        let oneAfterTheOther = await clock.measure {            let a = await locate("ZX-42")            let b = await locate("QF-7")            print(a ?? "?", b ?? "?")            let other = try await locate("AB-1")            print("AB-1 is at the \(other) depot.")        } catch CourierError.unknownParcel(let number) {            print("The courier has no parcel \(number).")        } catch {            print("Something else went wrong: \(error)")        }        print("One after the other:", seconds(oneAfterTheOther))        let together = await clock.measure {            async let a = locate("ZX-42")       // a child task, started here            async let b = locate("QF-7")        // and another, at once            print(await a ?? "?", await b ?? "?")        }        print("Together, with async let:", seconds(together))    }}

@MainActor    // the app calls run() on the main actor; each Task { } it starts begins there too
func run() {
    Task {
        do {
            let depot = try await locate("ZX-42")
            let away = await hours(from: depot)
            print("ZX-42 is at the \(depot) depot, \(away) hours away.")

            let other = try await locate("AB-1")
            print("AB-1 is at the \(other) depot.")
        } catch CourierError.unknownParcel(let number) {
            print("The courier has no parcel \(number).")
        } catch {
            print("Something else went wrong: \(error)")
        }
    }
}

@MainActor    // the app calls run() on the main actor; each Task { } it starts begins there toofunc run() {    Task {        do {            let depot = try await locate("ZX-42")            let away = await hours(from: depot)            print("ZX-42 is at the \(depot) depot, \(away) hours away.")            let other = try await locate("AB-1")            print("AB-1 is at the \(other) depot.")        } catch CourierError.unknownParcel(let number) {            print("The courier has no parcel \(number).")        } catch {            print("Something else went wrong: \(error)")        // a second task, also on the main actor; kept, so that it can be cancelled        let watching = Task {            do {                for hour in 1... {                    // stop if nobody is watching any more                    try Task.checkCancellation()                    try await Task.sleep(for: .seconds(1))     // the van's next report                    print("Hour \(hour): still on the van.")                }            } catch is CancellationError {                print("Stopped watching.")            } catch {                print("Something else went wrong: \(error)")            }        }        try? await Task.sleep(for: .seconds(2.5))        print("That's enough; cancel it. isCancelled before: \(watching.isCancelled)")        watching.cancel()        print("isCancelled after: \(watching.isCancelled)")        await watching.value        print("The watcher is done.")    }}

@MainActor    // the app calls run() on the main actor; each Task { } it starts begins there too
func run() {
    Task {
        // a second task, also on the main actor; kept, so that it can be cancelled
        let watching = Task {
            do {
                for hour in 1... {
                    // stop if nobody is watching any more
                    try Task.checkCancellation()
                    try await Task.sleep(for: .seconds(1))     // the van's next report
                    print("Hour \(hour): still on the van.")
                }
            } catch is CancellationError {
                print("Stopped watching.")
            } catch {
                print("Something else went wrong: \(error)")
            }
        }
        try? await Task.sleep(for: .seconds(2.5))
        print("That's enough; cancel it. isCancelled before: \(watching.isCancelled)")
        watching.cancel()
        print("isCancelled after: \(watching.isCancelled)")
        await watching.value
        print("The watcher is done.")
    }
}

import Foundation

/// The latest word about a parcel — what a screen would show. `@MainActor`: its properties may only be touched on the
/// main thread, where the screen is drawn. In this project nothing is on the main actor unless it says so.
@MainActor
final class Tracker {
    var latest = "nothing yet"
}

/// Words for the screen. A helper that belongs to no actor — `nonisolated`, said out loud — so that any code may call it.
nonisolated func report(_ depot: String, _ hours: Int, to tracker: Tracker) {
    tracker.latest = "At the \(depot) depot, \(hours) hours away"
}

/// Words for the screen. A helper that belongs to no actor — `nonisolated`, said out loud — so that any code may call it.nonisolated func report(_ depot: String, _ hours: Int, to tracker: Tracker) {    tracker.latest = "At the \(depot) depot, \(hours) hours away"/// Words for the screen. A helper that belongs to no actor — `nonisolated`, said out loud — so that any code may call/// it. It cannot touch the tracker, which belongs to the main actor: it hands the words back, and main-actor code/// stores them.nonisolated func report(_ depot: String, _ hours: Int) -> String {    "At the \(depot) depot, \(hours) hours away"}

/// Words for the screen. A helper that belongs to no actor — `nonisolated`, said out loud — so that any code may call
/// it. It cannot touch the tracker, which belongs to the main actor: it hands the words back, and main-actor code
/// stores them.
nonisolated func report(_ depot: String, _ hours: Int) -> String {
    "At the \(depot) depot, \(hours) hours away"
}

@MainActor    // the app calls run() on the main actor; each Task { } it starts begins there toofunc run() {    let tracker = Tracker()    Task {        // a second task, also on the main actor; kept, so that it can be cancelled        let watching = Task {            do {                for hour in 1... {                    // stop if nobody is watching any more                    try Task.checkCancellation()                    try await Task.sleep(for: .seconds(1))     // the van's next report                    print("Hour \(hour): still on the van.")                }            } catch is CancellationError {                print("Stopped watching.")            } catch {                print("Something else went wrong: \(error)")            }        do {            let depot = try await locate("ZX-42")            let away = await hours(from: depot)            // after the await, this task is back on the main actor            tracker.latest = report(depot, away)            print("The screen would show:", tracker.latest)        } catch {            print("Could not track it:", error)        }        try? await Task.sleep(for: .seconds(2.5))        print("That's enough; cancel it. isCancelled before: \(watching.isCancelled)")        watching.cancel()        print("isCancelled after: \(watching.isCancelled)")        await watching.value        print("The watcher is done.")    }}

@MainActor    // the app calls run() on the main actor; each Task { } it starts begins there too
func run() {
    let tracker = Tracker()
    Task {
        do {
            let depot = try await locate("ZX-42")
            let away = await hours(from: depot)
            // after the await, this task is back on the main actor
            tracker.latest = report(depot, away)
            print("The screen would show:", tracker.latest)
        } catch {
            print("Could not track it:", error)
        }
    }
}

import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack(alignment: .leading, spacing: 16) {
            HStack(alignment: .top, spacing: 12) {
                Text("📦")
                    .font(.system(size: 44))
                VStack(alignment: .leading) {
                    Text("Parcel")
                        .font(.title.bold())
                    Text("what run() printed")
                        .foregroundStyle(.secondary)
                }
                Spacer()
                VStack(spacing: 2) {
                    Text("\(WallClock.shared.ticks)")
                        .font(.system(.title, design: .rounded).monospacedDigit().bold())
                    Text("ticks")
                        .font(.caption)
                        .foregroundStyle(.secondary)
                }
            }
            ScrollView([.vertical, .horizontal]) {
                Text(Printed.shared.lines.joined(separator: "\n"))
                    .font(.system(size: 13, design: .monospaced))
                    .foregroundStyle(.green)
                    .fixedSize()
                    .padding()
            }
            .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
            .background(.black, in: .rect(cornerRadius: 18))
        }
        .padding()
        .background(Color.orange.opacity(0.12))
        .task {
            await WallClock.shared.tick(times: 150)
        }
    }
}

#Preview {
    ContentView()
}