From kotlin to Java, issue on kotlin generics

Question

I'm doing the code migration from java to kotlin and I have some problem with generics.

This is an example explaining my doubts:

import java.util.*
import kotlin.collections.HashMap

interface MyGenerics<T>{
  fun produce():T
  fun publish(toPublish:T):String
}

class MyImplementation:MyGenerics<Boolean>{

  override fun produce(): Boolean {
    return true
  }

  override fun publish(toPublish: Boolean): String {
    return "test"
  }

}

class RegistrationClass{

  private val workers = HashMap<String, Vector<MyGenerics<Any>>>()

  fun register(type: String, worker: MyGenerics<Any>) {
    if (!workers.containsKey(type)) workers[type] = Vector()
      workers[type]!!.add(worker)


   //usage example
   for (workers in workers[type]!!){
     val product = workers.produce()
     workers.publish(product)
    }
  }

}

fun main() {
   val registrationClass = RegistrationClass()
   registrationClass.register("MyTest", MyImplementation()) //error kotlin implementation

   val javaRegistrationClass = JavaRegistrationClass()
   javaRegistrationClass.register("MyNewTest", MyImplementation()) //java implementation

}

Why I'm getting error on

> registrationClass.register("MyTest", MyImplementation()) //error
> kotlin implementation

and not on:

javaRegistrationClass.register("MyNewTest", MyImplementation()) //java implementation

This is the JavaRestristrationClass:

class JavaRegistrationClass{

    private HashMap workers = new HashMap<String, Vector<MyOtherTest>>();

    public void register(String type, MyGenerics worker) {
        //do something
    }

}

I have read this https://stackoverflow.com/a/65534086/3681634 answer, but I continue to not understand

Answer 1

In java code you use raw type (MyGenerics), which is unsafe (and therefore was not added to Kotlin) and still present in java just for backwards-compatibility with code written before Java 5.

MyGenerics<Any> type you use instead, is not its equivalent. You need to either provide fair generic type MyGenerics<T> (and make your method generic), or use MyGenerics<*> type.

Since you deliberately mix elements of different types in one generic collection, unchecked casts is unavoidable in all cases.

Option 1 (with MyGenerics<T>):

class RegistrationClass {
    private val workers = HashMap<String, Vector<MyGenerics<Any>>>()

    fun <T> register(type: String, worker: MyGenerics<T>) {
        val workersOfType = workers.getOrPut(type) { Vector() }
        @Suppress("UNCHECKED_CAST")
        workersOfType.add(worker as MyGenerics<Any>)

        //usage example
        workersOfType.forEach { it.publish(it.produce()) }
    }
}

Option 2 (with MyGenerics<*>):

class RegistrationClass {
    private val workers = HashMap<String, Vector<MyGenerics<Any>>>()

    fun register(type: String, worker: MyGenerics<*>) {
        val workersOfType = workers.getOrPut(type) { Vector() }
        @Suppress("UNCHECKED_CAST")
        workersOfType.add(worker as MyGenerics<Any>)

        //usage example
        workersOfType.forEach { it.publish(it.produce()) }
    }
}

Also you may change type of your workers collection (as @Tenfour04 suggests in comments):

Options 1.1/2.1 (with MyGenerics<T>/MyGenerics<*> and Vector<MyGenerics<*>>):

class RegistrationClass {
    private val workers = HashMap<String, Vector<MyGenerics<*>>>()

    fun <T> register(type: String, worker: MyGenerics<T>) { 
//  fun register(type: String, worker: MyGenerics<*>) { //also possible
        val workersOfType = workers.getOrPut(type) { Vector() }
        workersOfType.add(worker)

        //usage example
        workersOfType.forEach {
            @Suppress("UNCHECKED_CAST")
            it as MyGenerics<Any>
            it.publish(it.produce())
        }
    }
}

UPDATE

Actually, it's possible to avoid casting with Options 1.1/2.1, if you can hide operations, revealing type of generic collection elements inside the interface (as @al3c suggests in comments):

interface MyGenerics<T> {
    fun produce(): T
    fun publish(toPublish: T): String
    fun produceAndPublish() = publish(produce())
}

class RegistrationClass {
    private val workers = HashMap<String, Vector<MyGenerics<*>>>()

    fun <T> register(type: String, worker: MyGenerics<T>) { 
//  fun register(type: String, worker: MyGenerics<*>) { //also possible
        val workersOfType = workers.getOrPut(type) { Vector() }
        workersOfType.add(worker)

        //usage example
        workersOfType.forEach { it.produceAndPublish() }
    }
}

Answer 2

I've done in this way:

class RegistrationClass{

  private val bookOrder = HashMap<String, Vector<MyGenerics<*>>>()

  fun register(type: String, worker: MyGenerics<*>) {
    if (!bookOrder.containsKey(type)) bookOrder[type] = Vector()
    bookOrder[type]!!.add(worker)
  }

  fun runExample(type:String){
    //usage example
    for (workers in bookOrder[type]!!){
      val product = workers.produce()
      @Suppress("UNCHECKED_CAST")
      (workers as MyGenerics<Any?>).publish(product)
    }
  }

}

fun main() {
  val registrationClass = RegistrationClass()
  registrationClass.register("MyTest", MyImplementation())
}

but i'm wondering: is there a way to not use the unchecked cast?