Error creating a generic function to decode array of Decodable object

[macshodan]

Hi,

I'm struggling with an error when trying to use a generic function to decode an array of objects conforming to the Decodable protocol. The function works when used to decode a single object but then I try to use it for arrays the compiler generate an error (it works fine on iOS obviously).

@inline(__always) private func fetchData<T: Decodable>(_ type: T.Type, request: URLRequest) async throws -> T {
        
        let session = URLSession.shared
        
        let (data, response) = try await session.data(for: request)
        
        guard let response = response as? HTTPURLResponse else {
            throw NetworkError.invalidURL
        }
        
        let statusCode = response.statusCode
        
        if statusCode == 401 {
            throw NetworkError.unauthorized
        }
        
        if let contentType = response.value(forHTTPHeaderField: "Content-Type") {
            if contentType == "application/json" {
                do {
                    let decoded = try decoder.decode(T.self, from: data)
                    return decoded
                } catch {
                    print(error)
                    throw NetworkError.decodingError(error.localizedDescription)
                }
            }
        }
        
        throw NetworkError.invalidStatusCode(statusCode)
    }

This is the generic function I'm using, basically it's a network wrapper api I'm using to simplify network calls. I'm using like this:

let dto: [DTO] = try await fetchData([DTO].self, request: request)

while it compile and works fine on iOS, I get the following skip compile error:

/Users/simo/Library/Developer/Xcode/DerivedData/SchoolbusEasy-hkvmapefknvfiqeabqesbtjwvixq/Build/Intermediates.noindex/BuildToolPluginIntermediates/oimmei-schoolbus-easy.output/SchoolbusEasy/skipstone/SchoolbusEasy/src/main/kotlin/schoolbus/easy/NetworkingService.kt:104:48 Argument type mismatch: actual type is 'KClass<Array<*>>', but 'KClass<Decodable & Array>' was expected.

It works fine if I try to decode a single object instead of an array.

Do you have any ideas on how to solve this, or it simply cannot be done?

thanks in advance

[marcprux]

The problem is that the Kotlin type reification only works with the outer type (the Array), and the inner type (T) is lost.

I've run into this issue as well, and my workaround was to make two variants of the decode function, like:

    @inline(__always) private func fetchSingle<T: Decodable>(_ type: T.Type, endpoint: String, filter: String?, params: [URLQueryItem]?) async throws -> T {
        let data = try await fetchData(endpoint: endpoint, filter: filter, params: params)
        let decoder = JSONDecoder()
        return try decoder.decode(T.self, from: data)
    }

    @inline(__always) private func fetchArray<T: Decodable>(_ type: T.Type, endpoint: String, filter: String?, params: [URLQueryItem]?) async throws -> [T] {
        let data = try await fetchData(endpoint: endpoint, filter: filter, params: params)
        let decoder = JSONDecoder()
        return try decoder.decode([T].self, from: data)
    }

Hopefully something like this won't be too cumbersome for you.

[macshodan]

Thanks Marc!

It's surely better than having to manually do all the session, decode and error handling for each call.