如何让Task扩展的泛型静态函数实现自动类型推断？

你遇到的编译器推断问题，根源在于当前的Task扩展是基于泛型类型Task<Success, Failure>实现的：调用Task.race或Task.all时，编译器需要先确定Task本身的Success和Failure泛型参数，但你的方法完全没有用到这两个参数，导致编译器无法自动推断，必须显式指定Task<Int, Error>才能消除歧义。

下面提供两种方案，让编译器可以自动推断返回类型和错误类型，无需显式声明：

方案1：改为全局异步函数 #

将race和all从Task的泛型扩展中剥离，做成全局函数，这样编译器可以直接从传入的闭包推断泛型类型：

// 全局实现race逻辑
func race<T>(_ tasks: [() async throws -> T]) async throws -> T {
    return try await withThrowingTaskGroup(of: T.self) { taskGroup in
        for task in tasks {
            taskGroup.addTask(operation: task)
        }
        // 替换强制解包，避免nil崩溃
        guard let firstResult = try await taskGroup.next() else {
            throw CancellationError()
        }
        taskGroup.cancelAll()
        return firstResult
    }
}

// 全局实现all逻辑
func all<T>(_ tasks: [() async throws -> T]) async throws -> [T] {
    return try await withThrowingTaskGroup(of: T.self) { taskGroup in
        for task in tasks {
            taskGroup.addTask(operation: task)
        }
        // iOS 16+/macOS 13+ 可直接用系统内置的collect()方法
        return try await taskGroup.collect()
    }
}

// 兼容iOS 15及以下版本的collectAsArray扩展（可选）
extension AsyncSequence {
    func collectAsArray() async rethrows -> [Element] {
        var results: [Element] = []
        for try await result in self {
            results.append(result)
        }
        return results
    }
}

调用方式（无需显式指定类型） #

let x = try await race([{ return 1 }, { return 2 }])
let y = try await all([{ return 1 }, { return 2 }])

方案2：保留Task命名空间，嵌套非泛型类型 #

如果希望方法仍挂在Task下，可以在Task扩展中嵌套一个非泛型的枚举/结构体，将方法放在其中，避免泛型推断冲突：

extension Task {
    enum Group {
        static func race<T>(_ tasks: [() async throws -> T]) async throws -> T {
            return try await withThrowingTaskGroup(of: T.self) { taskGroup in
                for task in tasks {
                    taskGroup.addTask(operation: task)
                }
                guard let firstResult = try await taskGroup.next() else {
                    throw CancellationError()
                }
                taskGroup.cancelAll()
                return firstResult
            }
        }
        
        static func all<T>(_ tasks: [() async throws -> T]) async throws -> [T] {
            return try await withThrowingTaskGroup(of: T.self) { taskGroup in
                for task in tasks {
                    taskGroup.addTask(operation: task)
                }
                return try await taskGroup.collect()
            }
        }
    }
}

// 兼容低版本的collectAsArray扩展（可选）
extension AsyncSequence {
    func collectAsArray() async rethrows -> [Element] {
        var results: [Element] = []
        for try await result in self {
            results.append(result)
        }
        return results
    }
}

调用方式 #

let x = try await Task.Group.race([{ return 1 }, { return 2 }])
let y = try await Task.Group.all([{ return 1 }, { return 2 }])

额外优化提示 #

• 原代码中return first!存在强制解包风险，如果所有任务被取消，taskGroup.next()会返回nil，建议用guard let捕获并抛出合理错误。
• iOS 16+/macOS 13+ 系统已经为ThrowingTaskGroup提供了collect()方法，无需自定义collectAsArray，低版本兼容时再保留你的扩展。

内容的提问来源于stack exchange，提问作者Ricky Mo