ProgressManager: Swift Concurrency における進捗報告

public class FoodProcessor {
    public func process(
        ingredients: [Ingredient],
        subprogress: consuming Subprogress? = nil
    ) async {
        let manager = subprogress?.start(totalCount: ingredients.count + 1)

        var choppedIngredients: [Ingredient] = []
        for ingredient in ingredients {
            let chopped = await Self.chop(
                ingredient,
                subprogress: manager?.subprogress(assigningCount: 1)
            )
            choppedIngredients.append(chopped)
        }

        // 進捗報告に対応していない関数の呼び出しは、自分で complete(count:) する
        await blender.blend(choppedIngredients)
        manager?.complete(count: 1)
    }

    static func chop(_ ingredient: Ingredient, subprogress: consuming Subprogress? = nil) -> Ingredient { ... }
}

let overallManager = ProgressManager(totalCount: 2)

await withTaskGroup(of: Void.self) { group in
    group.addTask {
        await foodProcessor.process(
            ingredients: mainCourse,
            subprogress: overallManager.subprogress(assigningCount: 1)
        )
    }
    group.addTask {
        await juicer.makeJuice(
            ingredients: beverage,
            subprogress: overallManager.subprogress(assigningCount: 1)
        )
    }
}

let subprogressOne = overall.subprogress(assigningCount: 1)
let managerOne = subprogressOne.start(totalCount: 10)

// COMPILER ERROR: 'subprogressOne' consumed more than once
let managerTwo = subprogressOne.start(totalCount: 8)

@available(FoundationPreview 6.4, *)
@dynamicMemberLookup
@Observable
public final class ProgressManager: Sendable, Hashable, Equatable,
    CustomStringConvertible, CustomDebugStringConvertible {

    public var totalCount: Int? { get }
    public var completedCount: Int { get }
    public var fractionCompleted: Double { get }
    public var isIndeterminate: Bool { get }
    public var isFinished: Bool { get }

    public var reporter: ProgressReporter { get }

    public convenience init(totalCount: Int?)

    public func subprogress(assigningCount count: Int) -> Subprogress
    public func assign(count: Int, to reporter: ProgressReporter)

    public func complete(count: Int)
    public func setCounts(_ counts: (_ completed: inout Int, _ total: inout Int?) -> Void)
}

let manager = ProgressManager(totalCount: nil)
// 後から件数が分かったタイミングでまとめて設定
manager.setCounts { completed, total in
    total = 100
    completed = 0
}

public class ExamCountdown {
    public var progressReporter: ProgressReporter { ... }
}

let examCountdown = ExamCountdown()
let observedProgress = examCountdown.progressReporter

let overall = ProgressManager(totalCount: 5)
overall.assign(count: 3, to: examCountdown.progressReporter)

let deadlineTracker = ProgressManager(totalCount: 2)
deadlineTracker.assign(count: 1, to: examCountdown.progressReporter)

let manager = ProgressManager(totalCount: 2)
let managerFractionStream = Observations { manager.fractionCompleted }

let reporter = manager.reporter
let reporterFractionStream = Observations { reporter.fractionCompleted }

let manager = ProgressManager(totalCount: 2)
manager.complete(count: 1)
manager.totalByteCount = 1_000_000

extension ProgressManager.Properties {
    var filename: Filename.Type { Filename.self }

    enum Filename: Sendable, ProgressManager.Property {
        typealias Value = String?
        typealias Summary = [String?]

        static var key: String { "ExampleApp.Filename" }
        static var defaultValue: String? { nil }
        static var defaultSummary: [String?] { [] }

        static func reduce(into summary: inout [String?], value: String?) {
            summary.append(value)
        }
        static func merge(_ summary1: [String?], _ summary2: [String?]) -> [String?] {
            summary1 + summary2
        }
        static func finalSummary(_ parentSummary: [String?], _ selfSummary: [String?]) -> [String?] {
            parentSummary + selfSummary
        }
    }
}

manager.filename = "Capybara.jpg"
await doSomething(subprogress: manager.subprogress(assigningCount: 1))

func doSomething(subprogress: consuming Subprogress? = nil) async {
    let manager = subprogress?.start(totalCount: 1)
    manager?.filename = "Snail.jpg"
}

let filenames = manager.summary(of: \.filename) // ["Capybara.jpg", "Snail.jpg"]

extension ProgressManager {
    public func assign(count: Int, to progress: Foundation.Progress)
}

let overall = ProgressManager(totalCount: 2)
let subprogressOne = overall.subprogress(assigningCount: 1)
let result = await doSomethingWithManager(subprogress: subprogressOne)

let legacyChild = doSomethingWithProgress() // 既存の Progress を返す関数
overall.assign(count: 1, to: legacyChild)

extension Progress {
    public func subprogress(assigningCount count: Int) -> Subprogress
    public func addChild(_ reporter: ProgressReporter, withPendingUnitCount count: Int)
}

let overall = Progress(totalUnitCount: 3)

let subprogressOne = doSomethingWithProgress()
overall.addChild(subprogressOne, withPendingUnitCount: 1)

let subprogressTwo = overall.subprogress(assigningCount: 1)
await doSomethingWithManager(subprogress: subprogressTwo)

let downloadReporter = DownloadManager().progressReporter
overall.addChild(downloadReporter, withPendingUnitCount: 1)