ios - 回调中的类型推断错误

Question

我有一个我无法解决的类型推断错误。我在下面附上了最重要的片段。解析过程由 APIClient 中的 Decoder 单独完成。

为什么 APIClient 的 execute 无法识别 T 是 [Chapter]因为行 completion(Result.success(decodedData)) 是那种类型？

func loadFeed(completion: @escaping (Result<[Chapter]>) -> Void) {
    APIClient.shared.execute(APIRequest.loadFeed) { response in

        guard let decodedData = response.decodedData else { return }
        completion(Result.success(decodedData))
    }
}

上面的代码片段是我在 Services 类中调用 APIClient 的方式。

class APIClient: APIClientProtocol {
    static let shared = APIClient()
    func execute<T: Decodable>(_ apiRequest: APIRequestDefining,
                               responseDecoder: ResponseDecoder = .jsonDecoding,
                               completionHandler: @escaping (Response<T>) -> Void) {
        var response = Response<T>(request: request, httpResponse: dataResponse.response, data: dataResponse.data)

        do {
            try responseDecoder.decode(response: &response)
        } catch {
            response.error = error
        }

        completionHandler(response)
    }
}



public struct Response<T> {
    var decodedData: T?
}



enum Result<Value> {
    case success(Value)
    case failure(Error)
}

编辑:澄清一下，下面的代码片段是我在哪里以及如何将原始响应解码为推断的对象。

struct JSONResponseDecoder: ResponseDecoding {
    func decode<T: Decodable>(response: inout Response<T>) throws {
        guard let data = response.data else { return }
        do {
            try response.decodedData = JSONDecoder().decode(T.self, from: data)
        } catch {
            throw(ApplicationError(errorType: .decodingError))
        }
    }
}

编辑!!!!:

我发现了一个很奇怪的事情，我删除了带有guard 的行，它工作正常，这是为什么？

之前: 之后:

Answer 1

你说，“执行不承认 T 是 [Chapter]”，我想知道你为什么这么期望。

您有一个 loadFeed 函数，它有一个使用通用类型 Chapter 的完成 block 。

然后你有一个带有泛型类型 T 的执行方法。当你调用你的执行方法时，它不知道关于类型 Chapter 的任何信息。

我遇到与您相同的错误的示例:

 func execute<T>(completionHandler: @escaping (T) -> Void) {

 }
 self.execute { (result) in
 }

解决方案是转换参数，以便可以推断出 T。在你的情况下:

func execute<T>(completionHandler: @escaping (T) -> Void) {

 }
 self.execute { (result:[Chapter]) in
 }

泛型很棒 :)