Is generic code is not supported in Skip

[DominatorVbN]

Trying to write below function in swift:

    func fetch<T: Decodable>(
        api: TMDBAPI
    ) async throws -> T {
        let request = try api.getURLRequest()
        let (data, _) = try await URLSession.shared.data(for: request)
        let decodedData = try JSONDecoder().decode(T.self, from: data)
        return decodedData
    }
    ```
    
    Facing issue:
    
    ```
    Cannot use 'T' as reified type parameter. Use a class instead.
    ```

[marcprux]

The Skip transpiler supports many Swift generic constructs, but not everything. We are constrained by Kotlin's limitations, and in this case the limitations of reified type parameters on the JVM (which famously implements generics though type erasure, and thus cannot provide runtime information about the types based on the signature alone).

This is one such limitation: you can't reference T.self when all you have is a type parameter: you'll need an instance, or the type itself, to be passed as a parameter.

I think this might work:

    func fetch<T: Decodable>(typeParam: T.Self,
        api: TMDBAPI
    ) async throws -> T {
        let request = try api.getURLRequest()
        let (data, _) = try await URLSession.shared.data(for: request)
        let decodedData = try JSONDecoder().decode(typeParam, from: data)
        return decodedData
    }

These generics limitations are mentioned in the Swift Support page, but we will expand on this in the coming days to discuss alternative implementations to work around generic limitations.

[DominatorVbN]

Tried with below code as well, it is not working as of now, pretty interested to getting this working, though i am not fully read the docs yet, will go through the docs and understand if i could get some idea working around this.

    func fetch<T>(_ type: T.Type, api: TMDBAPI) async throws -> T where T : Decodable {
        let request = try api.getURLRequest()
        let (data, _) = try await URLSession.shared.data(for: request)
        let decodedData = try JSONDecoder().decode(type, from: data)
        return decodedData
    }
    ```

[pabloruan0710]

@DominatorVbN worked for you now?

[sturmenta]

@pabloruan0710 as far as I could see, he finally decided not to use generics

class TMDBApiProvider {
    
    enum RequestError: Error {
        case unableToCreate
        case dataNotFound
    }
    
    func fetchMovies(
        api: TMDBAPI
    ) async throws -> PaginatedMovieResponse {
        let request = try api.getURLRequest()
        NetworkLogger.log(request: request)
        let (data, response) = try await URLSession.shared.data(for: request)
        NetworkLogger.log(data: data, response: response, error: nil)
        let decodedData = try JSONDecoder().decode(PaginatedMovieResponse.self, from: data)
        return decodedData
    }
}

and sadly the code example of Marc didn't work for me either

[sturmenta]

I think an example of doing a simple fetch with generics would be great to have in docs @marcprux

[aabewhite]

See: https://skip.tools/docs/modules/skip-lib/#codable

[sturmenta]

thanks @aabewhite 🙌 with this docs and this example of Marc I was able to come up with a piece of code that worked for me.

import SwiftUI

enum FetchDataError: Error {
    case invalidUrl
    case invalidResponse
    case invalidData
}

@inline(__always) func fetchData<T>(_ type: T.Type, endpoint: String) async throws -> T where T: Decodable {
    guard let url = URL(string: endpoint) else {
        throw FetchDataError.invalidUrl
    }

    let (data, response) = try await URLSession.shared.data(from: url)

    guard let response = response as? HTTPURLResponse, response.statusCode == 200 else {
        throw FetchDataError.invalidResponse
    }

    do {
        let decoder = JSONDecoder()
        decoder.keyDecodingStrategy = .convertFromSnakeCase
        return try decoder.decode(type, from: data)
    } catch {
        throw FetchDataError.invalidData
    }
}

and call like this:

struct View_AboutUs: View {
  @State private var ghUser: GHUser?
  
  var body: some View {
      VStack {
          Text(ghUser?.login ?? "GH Username")
      }
      .task {
          do {
              ghUser = try await getGHUser()
          } catch FetchDataError.invalidUrl {
              print("~~~ invalid url")
          } catch FetchDataError.invalidResponse {
              print("~~~ invalid response")
          } catch FetchDataError.invalidData {
              print("~~~ invalid data")
          } catch {
              print("~~~ unexpected error")
          }
      }
  }
  
  func getGHUser() async throws -> GHUser {
      return try await fetchData(GHUser.self, endpoint: "https://api.github.com/users/sturmenta")
  }
}

struct GHUser: Codable {
    let login: String
}