Method to download using generics asks for more context - swift

Question

I wrote a method using generics in order to make it reusable to any kind of download. It downloads json arrays and returns a generic object or an error.
This is my class to download json arrays from server:
import Foundation
enum Result<T> {
case success(T)
case failure(Error)
}
class LTLNetworkClient: NSObject {
fileprivate var session : URLSession
fileprivate var objectTask : URLSessionDataTask?
override init() {
let config = URLSessionConfiguration.ephemeral
config.timeoutIntervalForResource = 5
config.timeoutIntervalForRequest = 5
self.session = URLSession.init(configuration: config)
}
/**
Download asynchronously json object from Server and returns it into generic data models
*/
func getData<K: Codable>(request: URLRequest, completion: #escaping (Result<[K]>) -> Void) {
let sessionDataTask = URLSession.shared.dataTask(with: request) { (responseData, response, responseError) in
if let jsonData = responseData {
let decoder = JSONDecoder()
do {
let response = try decoder.decode([K].self, from: jsonData)
let result: Result<[K]> = Result.success(response)
completion(result)
} catch {
completion(.failure(error))
}
} else if let error = responseError {
completion(.failure(error))
} else {
let error = NSError(domain: "Cannot form jsonData with Response Data", code: 501, userInfo: nil)
completion(.failure(error))
}
}
sessionDataTask.resume()
}
}
And this is how I call the method and the error I get:
Does anyone knows how to fix it and why this error appears?
Many thx in advance

Answer 1

Here's your method declaration:
func getData<K: Codable>(request: URLRequest, completion: #escaping (Result<[K]>) -> Void)
This method has a type parameter, K, which is only used in the type of the completion argument. When the compiler sees a call to getData, it has to deduce a concrete type for K based on the argument type of the closure you pass as completion.
And here's your call:
networkClient.getData(request: urlRequest) { (result) in
// Do stuff
}
In this call, the completion closure is { (result) in }. What is the type of result? There is no information given about it, so all the compiler knows is that result must be type Result<[K]> for some type K. It has no way to deduce a concrete type for K, so it emits an error.
You can make the type explicit like this:
networkClient.getData(request: urlRequest) { (_ result: Result<[SomeConcreteCodableType]>) -> Void in
// Do stuff
}
where SomeConcreteCodableType is some concrete type that conforms to Codable. The Codable conformance is required because of the constraint in getData's declaration.
A different solution is to change getData to take another argument that lets the caller specify K directly:
func getArray<K: Codable>(of: K.Type, for request: URLRequest,
completion: #escaping (Result<[K]>) -> Void) {
...
}
Then you call it like this:
networkClient.getArray(of: SomeConcreteCodableType.self, for: request) { result in
// Do stuff
}