Async/Await Task扩展超时方法编译错误求助

最近在给Async/Await的Task写超时扩展方法时卡壳了，遇到两个编译错误，翻了好多资料都没搞懂，特意来求助各位大佬！

我的代码和遇到的错误 #

先把我写的代码贴出来：

import Foundation

func test() async throws {
    // 错误1：Generic parameter 'Failure' could not be inferred
    let result = try await Task.withTimeout(after: .seconds(0.1)) {
        try await test2()
    }
}

func test2() async throws -> Int {
    return 42 // 补个返回值方便测试
}

extension Task {
    static func withTimeout<T: Sendable>(
        after duration: Duration,
        operation: @escaping @Sendable () async throws -> T
    ) async throws -> T {
        try await withThrowingTaskGroup(of: T.self) { group in
            group.addTask {
                try await operation()
            }
            
            group.addTask {
                // 错误2：Referencing static method 'sleep(for:tolerance:clock:)' on 'Task' requires the types 'Failure' and 'Never' be equivalent
                try await Task.sleep(for: duration)
                throw CancellationError()
            }
            
            guard let result = try await group.next() else {
                throw CancellationError()
            }
            group.cancelAll()
            return result
        }
    }
}

编译时弹出两个错误：

1. Generic parameter 'Failure' could not be inferred
2. Referencing static method 'sleep(for:tolerance:clock:)' on 'Task' requires the types 'Failure' and 'Never' be equivalent

我对着这两个错误看了半天，还是没搞懂为什么会出现，有没有朋友能帮忙分析下？

已找到解决方案！ #

后来我终于找到能正常编译的实现方式，这里分享给大家，也方便遇到同样问题的朋友参考：

问题的根源在于Task本身是泛型类型（Task<Success, Failure>），直接给它加无约束的静态扩展会导致泛型冲突。下面是修正后的代码：

import Foundation

// 修正后的Task扩展版本
extension Task where Failure == Error {
    static func withTimeout<T: Sendable>(
        after duration: Duration,
        operation: @escaping @Sendable () async throws -> T
    ) async throws -> T {
        return try await withThrowingTaskGroup(of: Result<T, Error>.self) { group in
            // 执行目标操作
            group.addTaskUnlessCancelled {
                do {
                    return .success(try await operation())
                } catch {
                    return .failure(error)
                }
            }
            
            // 超时任务
            group.addTaskUnlessCancelled {
                try await Task.sleep(for: duration)
                return .failure(CancellationError())
            }
            
            // 获取第一个完成的任务结果
            let result = try await group.next()!
            group.cancelAll() // 取消剩余任务
            
            return try result.get()
        }
    }
}

// 或者更简洁的全局函数版本（避开Task泛型约束）
func withTimeout<T: Sendable>(
    _ duration: Duration,
    operation: @escaping @Sendable () async throws -> T
) async throws -> T {
    return try await withThrowingTaskGroup(of: T.self) { group in
        group.addTask { try await operation() }
        group.addTask {
            try await Task.sleep(for: duration)
            throw CancellationError()
        }
        
        guard let result = try await group.next() else {
            throw CancellationError()
        }
        group.cancelAll()
        return result
    }
}

// 测试调用
func test() async throws {
    // 用扩展版本调用
    let result = try await Task.withTimeout(after: .seconds(0.1)) {
        try await test2()
    }
    print(result)
}

func test2() async throws -> Int {
    try await Task.sleep(for: .seconds(0.2)) // 模拟耗时操作
    return 42
}

错误原因解析 #

1. 关于第一个错误：
   直接给Task加无约束的静态扩展时，编译器无法推断Task的Failure泛型类型，调用Task.withTimeout时就会报“无法推断泛型参数Failure”的错误。给扩展加上where Failure == Error的约束，就能明确泛型类型，解决推断问题。

2. 关于第二个错误：
   Task.sleep返回的是Task<Void, Never>，意味着这个任务永远不会抛出错误（Failure类型是Never）。而原来代码中group.addTask的闭包是async throws的，对应Task<T, Failure>，但Failure和Never类型不兼容，所以编译器报错。把任务结果包装成Result<T, Error>，或者改用全局函数（避开Task的泛型约束），就能解决这个类型不匹配的问题。

希望这个解答能帮到和我一样卡在这里的朋友，也欢迎大家分享其他更优雅的实现方式！

内容来源于stack exchange