Every trip's weather at once, a cache that is an actor, and an actor of your own

import SwiftUI

/// The weather in every city the trips go to.
struct WeatherStrip: View {
    let cities: [String]
    @State private var weather: [String: Weather] = [:]

    var body: some View {
        ScrollView(.horizontal) {
            HStack {
                ForEach(cities, id: \.self) { city in
                    if let now = weather[city] {
                        Label("\(city) \(now.temperature, format: .number.precision(.fractionLength(0)))°", systemImage: now.sky.symbol)
                    } else {
                        Label("\(city) …", systemImage: "cloud")
                    }
                }
                .padding(.horizontal, 12)
                .padding(.vertical, 8)
                .background(.thinMaterial, in: .capsule)
            }
            .padding(.horizontal)
        }
        .scrollIndicators(.hidden)
        .task {
            let start = ContinuousClock.now
            /// How long since the strip began asking, such as "0.42 sec".
            func elapsed() -> String {
                start.duration(to: .now).formatted(.units(allowed: [.seconds], fractionalPart: .show(length: 2)))
            }
            for city in cities {
                print("asked about \(city) at \(elapsed())")
                weather[city] = try? await Weather.now(in: city)
                print("answered about \(city) at \(elapsed())")
            }
        }
    }
}

struct ContentView: View {    @Environment(TripStore.self) private var store    @AppStorage(Settings.showsYearKey) private var showsYear = true    @State private var filter = TripFilter.all    @State private var closings = 0    var body: some View {        @Bindable var store = store        ScrollView {            LazyVStack(spacing: 12) {                TripPlanner()                    .environment(\.highlight, .mint)                PhotoStrip(trips: store.trips)                TripSummary(trips: store.trips)                WeatherStrip(cities: store.trips.map(\.city))                if showsYear {                    YearGrid(trips: store.trips)                }                FilterBar(filters: filters, selection: $filter) { trips in                    store.makeFavorites(trips)                }                    .frame(maxWidth: .infinity, alignment: .leading)                    .padding(.horizontal)                HStack {                    Menu("Sort", systemImage: "arrow.up.arrow.down") {                        Button("By date") { store.trips.sort { $0.start < $1.start } }                        Button("By price") { store.trips.sort { $0.price < $1.price } }                    }                    Spacer()                    Button("Close all", systemImage: "chevron.up") { closings += 1 }                }                .padding(.horizontal)                LazyVGrid(columns: [GridItem(.adaptive(minimum: 300))], spacing: 12) {                    ForEach($store.trips.filter { filter.includes($0.wrappedValue) }) { $trip in                        TripCard(trip: $trip)                    }                    .reorderable()                }                .reorderContainer(for: Trip.self, isEnabled: filter == .all) { difference in                    switch difference.destination.position {                    case .before(let id): store.move(difference.sources, before: id)                    case .end: store.move(difference.sources, before: nil)                    }                }                .id(closings)            }        }        .sensoryFeedback(.success, trigger: store.trips.filter(\.isFavorite).count)    }    /// All, Favorites, and then a filter for each country that has a trip.    private var filters: [TripFilter] {        var countries: [String] = []        for trip in store.trips where !countries.contains(trip.country) {            countries.append(trip.country)        }        return [.all, .favorites] + countries.map { TripFilter.country($0) }    }}

struct ContentView: View {
    @Environment(TripStore.self) private var store
    @AppStorage(Settings.showsYearKey) private var showsYear = true
    @State private var filter = TripFilter.all
    @State private var closings = 0

    var body: some View {
        @Bindable var store = store
        ScrollView {
            LazyVStack(spacing: 12) {
                TripPlanner()
                    .environment(\.highlight, .mint)
                PhotoStrip(trips: store.trips)
                TripSummary(trips: store.trips)
                WeatherStrip(cities: store.trips.map(\.city))
                if showsYear {
                    YearGrid(trips: store.trips)
                }
                FilterBar(filters: filters, selection: $filter) { trips in
                    store.makeFavorites(trips)
                }
                    .frame(maxWidth: .infinity, alignment: .leading)
                    .padding(.horizontal)
                HStack {
                    Menu("Sort", systemImage: "arrow.up.arrow.down") {
                        Button("By date") { store.trips.sort { $0.start < $1.start } }
                        Button("By price") { store.trips.sort { $0.price < $1.price } }
                    }
                    Spacer()
                    Button("Close all", systemImage: "chevron.up") { closings += 1 }
                }
                .padding(.horizontal)
                LazyVGrid(columns: [GridItem(.adaptive(minimum: 300))], spacing: 12) {
                    ForEach($store.trips.filter { filter.includes($0.wrappedValue) }) { $trip in
                        TripCard(trip: $trip)
                    }
                    .reorderable()
                }
                .reorderContainer(for: Trip.self, isEnabled: filter == .all) { difference in
                    switch difference.destination.position {
                    case .before(let id): store.move(difference.sources, before: id)
                    case .end: store.move(difference.sources, before: nil)
                    }
                }
                .id(closings)
            }
        }
        .sensoryFeedback(.success, trigger: store.trips.filter(\.isFavorite).count)
    }

    /// All, Favorites, and then a filter for each country that has a trip.
    private var filters: [TripFilter] {
        var countries: [String] = []
        for trip in store.trips where !countries.contains(trip.country) {
            countries.append(trip.country)
        }
        return [.all, .favorites] + countries.map { TripFilter.country($0) }
    }
}

import SwiftUI/// The weather in every city the trips go to.struct WeatherStrip: View {    let cities: [String]    @State private var weather: [String: Weather] = [:]    var body: some View {        ScrollView(.horizontal) {            HStack {                ForEach(cities, id: \.self) { city in                    if let now = weather[city] {                        Label("\(city) \(now.temperature, format: .number.precision(.fractionLength(0)))°", systemImage: now.sky.symbol)                    } else {                        Label("\(city) …", systemImage: "cloud")                    }                }                .padding(.horizontal, 12)                .padding(.vertical, 8)                .background(.thinMaterial, in: .capsule)            }            .padding(.horizontal)        }        .scrollIndicators(.hidden)        .task {            let start = ContinuousClock.now            /// How long since the strip began asking, such as "0.42 sec".            func elapsed() -> String {                start.duration(to: .now).formatted(.units(allowed: [.seconds], fractionalPart: .show(length: 2)))            }            for city in cities {                print("asked about \(city) at \(elapsed())")                weather[city] = try? await Weather.now(in: city)                print("answered about \(city) at \(elapsed())")            await withTaskGroup(of: (String, Weather?).self) { group in                for city in cities {                    group.addTask {                        print("asked about \(city) at \(elapsed())")                        return (city, try? await Weather.now(in: city))                    }                }                for await (city, answer) in group {                    print("answered about \(city) at \(elapsed())")                    weather[city] = answer                }            }        }    }}

import SwiftUI

/// The weather in every city the trips go to.
struct WeatherStrip: View {
    let cities: [String]
    @State private var weather: [String: Weather] = [:]

    var body: some View {
        ScrollView(.horizontal) {
            HStack {
                ForEach(cities, id: \.self) { city in
                    if let now = weather[city] {
                        Label("\(city) \(now.temperature, format: .number.precision(.fractionLength(0)))°", systemImage: now.sky.symbol)
                    } else {
                        Label("\(city) …", systemImage: "cloud")
                    }
                }
                .padding(.horizontal, 12)
                .padding(.vertical, 8)
                .background(.thinMaterial, in: .capsule)
            }
            .padding(.horizontal)
        }
        .scrollIndicators(.hidden)
        .task {
            let start = ContinuousClock.now
            /// How long since the strip began asking, such as "0.42 sec".
            func elapsed() -> String {
                start.duration(to: .now).formatted(.units(allowed: [.seconds], fractionalPart: .show(length: 2)))
            }
            await withTaskGroup(of: (String, Weather?).self) { group in
                for city in cities {
                    group.addTask {
                        print("asked about \(city) at \(elapsed())")
                        return (city, try? await Weather.now(in: city))
                    }
                }
                for await (city, answer) in group {
                    print("answered about \(city) at \(elapsed())")
                    weather[city] = answer
                }
            }
        }
    }
}

import Foundation

/// The weather already asked for, shared by every screen — with the questions still on their way.
actor WeatherCache {
    static let shared = WeatherCache()

    private var answers: [String: Task<Weather, any Error>] = [:]

    /// The weather in a city: an answer already given, a question already asked, or a new question.
    func weather(in city: String) async throws -> Weather {
        if let asked = answers[city] {
            return try await asked.value
        }
        let question = Task { try await Weather.now(in: city) }
        answers[city] = question
        do {
            return try await question.value
        } catch {
            answers[city] = nil         // a failure is not kept: the next question asks again
            throw error
        }
    }

    /// Forgets a city's weather, so that the next question asks Open-Meteo again.
    func forget(_ city: String) {
        answers[city] = nil
    }
}

import SwiftUI/// The weather in every city the trips go to.struct WeatherStrip: View {    let cities: [String]    @State private var weather: [String: Weather] = [:]    var body: some View {        ScrollView(.horizontal) {            HStack {                ForEach(cities, id: \.self) { city in                    if let now = weather[city] {                        Label("\(city) \(now.temperature, format: .number.precision(.fractionLength(0)))°", systemImage: now.sky.symbol)                    } else {                        Label("\(city) …", systemImage: "cloud")                    }                }                .padding(.horizontal, 12)                .padding(.vertical, 8)                .background(.thinMaterial, in: .capsule)            }            .padding(.horizontal)        }        .scrollIndicators(.hidden)        .task {            let start = ContinuousClock.now            /// How long since the strip began asking, such as "0.42 sec".            func elapsed() -> String {                start.duration(to: .now).formatted(.units(allowed: [.seconds], fractionalPart: .show(length: 2)))            }            await withTaskGroup(of: (String, Weather?).self) { group in                for city in cities {                    group.addTask {                        print("asked about \(city) at \(elapsed())")                        return (city, try? await Weather.now(in: city))                        return (city, try? await WeatherCache.shared.weather(in: city))                    }                }                for await (city, answer) in group {                    print("answered about \(city) at \(elapsed())")                    weather[city] = answer                }            }        }    }}

import SwiftUI

/// The weather in every city the trips go to.
struct WeatherStrip: View {
    let cities: [String]
    @State private var weather: [String: Weather] = [:]

    var body: some View {
        ScrollView(.horizontal) {
            HStack {
                ForEach(cities, id: \.self) { city in
                    if let now = weather[city] {
                        Label("\(city) \(now.temperature, format: .number.precision(.fractionLength(0)))°", systemImage: now.sky.symbol)
                    } else {
                        Label("\(city) …", systemImage: "cloud")
                    }
                }
                .padding(.horizontal, 12)
                .padding(.vertical, 8)
                .background(.thinMaterial, in: .capsule)
            }
            .padding(.horizontal)
        }
        .scrollIndicators(.hidden)
        .task {
            let start = ContinuousClock.now
            /// How long since the strip began asking, such as "0.42 sec".
            func elapsed() -> String {
                start.duration(to: .now).formatted(.units(allowed: [.seconds], fractionalPart: .show(length: 2)))
            }
            await withTaskGroup(of: (String, Weather?).self) { group in
                for city in cities {
                    group.addTask {
                        print("asked about \(city) at \(elapsed())")
                        return (city, try? await WeatherCache.shared.weather(in: city))
                    }
                }
                for await (city, answer) in group {
                    print("answered about \(city) at \(elapsed())")
                    weather[city] = answer
                }
            }
        }
    }
}

import Foundation/// The weather where a trip goes, as its screen shows it: on its way, here, or not to be had./// `@MainActor`: the screen reads it.@MainActor@Observablefinal class WeatherModel {    /// `Sendable`: plain data — and a type nested in the class does not take the class's actor.    enum Phase: Sendable {        case loading        case loaded(Weather)        case failed(String)    }    private(set) var phase = Phase.loading    /// Starts from nothing: the screen says the weather is on its way.    func load(for city: String) async {        phase = .loading        await refresh(for: city)        await show(city)    }    /// Asks again, and keeps what the screen shows until the answer comes.    /// Asks Open-Meteo again, and keeps what the screen shows until the answer comes.    func refresh(for city: String) async {        await WeatherCache.shared.forget(city)        await show(city)    }    /// The city's weather from the cache, which asks Open-Meteo only if nobody has yet.    private func show(_ city: String) async {        let next: Phase        do {            next = .loaded(try await Weather.now(in: city))            next = .loaded(try await WeatherCache.shared.weather(in: city))        } catch {            next = .failed(error.localizedDescription)        }        // the screen went away, or the city changed: nobody is waiting for this answer now        if !Task.isCancelled {            phase = next        }    }}

import Foundation

/// The weather where a trip goes, as its screen shows it: on its way, here, or not to be had.
/// `@MainActor`: the screen reads it.
@MainActor
@Observable
final class WeatherModel {
    /// `Sendable`: plain data — and a type nested in the class does not take the class's actor.
    enum Phase: Sendable {
        case loading
        case loaded(Weather)
        case failed(String)
    }

    private(set) var phase = Phase.loading

    /// Starts from nothing: the screen says the weather is on its way.
    func load(for city: String) async {
        phase = .loading
        await show(city)
    }

    /// Asks Open-Meteo again, and keeps what the screen shows until the answer comes.
    func refresh(for city: String) async {
        await WeatherCache.shared.forget(city)
        await show(city)
    }

    /// The city's weather from the cache, which asks Open-Meteo only if nobody has yet.
    private func show(_ city: String) async {
        let next: Phase
        do {
            next = .loaded(try await WeatherCache.shared.weather(in: city))
        } catch {
            next = .failed(error.localizedDescription)
        }
        // the screen went away, or the city changed: nobody is waiting for this answer now
        if !Task.isCancelled {
            phase = next
        }
    }
}

import Foundation

/// The actor the weather's types share: the cache in memory and the copy on disk. On one actor they use each other
/// directly, with no `await` — so a look at one and a change to the other happen in one step.
@globalActor
actor WeatherActor {
    static let shared = WeatherActor()
}

import Foundation

/// The weather as it was last answered, kept in a file, so that the next launch has it at once. Its reads and writes
/// are synchronous: each holds its thread until the disk is done.
@WeatherActor
final class WeatherDisk {
    /// One city's weather, and when Open-Meteo gave it.
    private struct Saved: Codable {
        let place: String
        let temperature: Double
        let code: Int
        let at: Date
    }

    private let file = URL.cachesDirectory.appending(path: "weather.json")
    private var saved: [String: Saved]

    /// Reads the file. `nonisolated`, so that a cache can be made with a disk from any code.
    nonisolated init() {
        let data = try? Data(contentsOf: file)
        saved = data.flatMap { try? JSONDecoder().decode([String: Saved].self, from: $0) } ?? [:]
    }

    /// A city's weather, if it was answered in the last ten minutes.
    func recent(in city: String) -> Weather? {
        guard let kept = saved[city], kept.at > .now - 600 else {
            return nil
        }
        return Weather(place: kept.place, temperature: kept.temperature, code: kept.code)
    }

    /// Keeps a city's new weather, and writes the file.
    func save(_ weather: Weather, for city: String) {
        saved[city] = Saved(place: weather.place, temperature: weather.temperature, code: weather.code, at: .now)
        write()
        print("Saved \(city) to disk, on \(queueName())")
    }

    /// Forgets a city's weather, so that the next question asks Open-Meteo.
    func forget(_ city: String) {
        saved[city] = nil
        write()
    }

    private func write() {
        try? JSONEncoder().encode(saved).write(to: file, options: .atomic)
    }
}

/// The dispatch queue running this code, such as "com.apple.root.user-initiated-qos.cooperative". On no actor:
/// it answers for whoever calls it.
func queueName() -> String {
    String(cString: __dispatch_queue_get_label(nil))
}

import Foundation/// The weather already asked for, shared by every screen — with the questions still on their way.actor WeatherCache {    static let shared = WeatherCache()/// The weather already asked for, shared by every screen — with the questions still on their way, and, for the cache/// every screen shares, a copy on disk.@WeatherActorfinal class WeatherCache {    /// The cache every screen shares, with a copy on disk. `nonisolated`: any code may reach it with no `await`, as it    /// could when the cache was an actor; its methods are WeatherActor's.    nonisolated static let shared = WeatherCache(disk: WeatherDisk())    private var answers: [String: Task<Weather, any Error>] = [:]    private let disk: WeatherDisk?    /// The weather in a city: an answer already given, a question already asked, or a new question.    /// `disk`: where answers are kept between launches — nowhere, unless the cache is given one. `nonisolated`, so that    /// any code may make a cache.    nonisolated init(disk: WeatherDisk? = nil) {        self.disk = disk    }    /// The weather in a city: an answer already given, a question already asked, an answer on disk from the last ten    /// minutes, or a new question.    func weather(in city: String) async throws -> Weather {        if let asked = answers[city] {            return try await asked.value        }        // the disk is on WeatherActor too: no await, so no gap        if let recent = disk?.recent(in: city) {            print("Found \(city) on disk")            return recent        }        let question = Task { try await Weather.now(in: city) }        answers[city] = question        do {            return try await question.value            let answer = try await question.value            disk?.save(answer, for: city)            return answer        } catch {            answers[city] = nil         // a failure is not kept: the next question asks again            throw error        }    }    /// Forgets a city's weather, so that the next question asks Open-Meteo again.    /// Forgets a city's weather — in memory and on disk — so that the next question asks Open-Meteo again.    func forget(_ city: String) {        answers[city] = nil        disk?.forget(city)    }}

import Foundation

/// The weather already asked for, shared by every screen — with the questions still on their way, and, for the cache
/// every screen shares, a copy on disk.
@WeatherActor
final class WeatherCache {
    /// The cache every screen shares, with a copy on disk. `nonisolated`: any code may reach it with no `await`, as it
    /// could when the cache was an actor; its methods are WeatherActor's.
    nonisolated static let shared = WeatherCache(disk: WeatherDisk())

    private var answers: [String: Task<Weather, any Error>] = [:]
    private let disk: WeatherDisk?

    /// `disk`: where answers are kept between launches — nowhere, unless the cache is given one. `nonisolated`, so that
    /// any code may make a cache.
    nonisolated init(disk: WeatherDisk? = nil) {
        self.disk = disk
    }

    /// The weather in a city: an answer already given, a question already asked, an answer on disk from the last ten
    /// minutes, or a new question.
    func weather(in city: String) async throws -> Weather {
        if let asked = answers[city] {
            return try await asked.value
        }
        // the disk is on WeatherActor too: no await, so no gap
        if let recent = disk?.recent(in: city) {
            print("Found \(city) on disk")
            return recent
        }
        let question = Task { try await Weather.now(in: city) }
        answers[city] = question
        do {
            let answer = try await question.value
            disk?.save(answer, for: city)
            return answer
        } catch {
            answers[city] = nil         // a failure is not kept: the next question asks again
            throw error
        }
    }

    /// Forgets a city's weather — in memory and on disk — so that the next question asks Open-Meteo again.
    func forget(_ city: String) {
        answers[city] = nil
        disk?.forget(city)
    }
}

import Foundation/// The actor the weather's types share: the cache in memory and the copy on disk. On one actor they use each other/// directly, with no `await` — so a look at one and a change to the other happen in one step.@globalActoractor WeatherActor {    static let shared = WeatherActor()    /// The disk's reads and writes block their thread, and the shared pool's threads must never block: so the    /// weather runs on a serial queue of its own.    private let queue = DispatchSerialQueue(label: "trips.weather")    nonisolated var unownedExecutor: UnownedSerialExecutor {        queue.asUnownedSerialExecutor()    }}

import Foundation

/// The actor the weather's types share: the cache in memory and the copy on disk. On one actor they use each other
/// directly, with no `await` — so a look at one and a change to the other happen in one step.
@globalActor
actor WeatherActor {
    static let shared = WeatherActor()

    /// The disk's reads and writes block their thread, and the shared pool's threads must never block: so the
    /// weather runs on a serial queue of its own.
    private let queue = DispatchSerialQueue(label: "trips.weather")

    nonisolated var unownedExecutor: UnownedSerialExecutor {
        queue.asUnownedSerialExecutor()
    }
}