Kotlin out-projected type prohibits the use

user_1243994 0
Viewed 5669

I recently tried the following in Kotlin. The idea is that I will receive as input an Item (like AmericanItem for instance) that extends BaseItem. I am trying to have a different parser for each of theses items Here is a sample code

abstract class BaseItem
class AmericanItem : BaseItem()
class EuropeanItem : BaseItem()

interface ItemParser<T : BaseItem> {
    fun parse(item: T)
}

class AmericanItemParser : ItemParser<AmericanItem> {
    override fun parse(item: AmericanItem) {
        println("AmericanItemParser")
    }
}

class EuropeanItemParser : ItemParser<EuropeanItem> {
    override fun parse(item: EuropeanItem) {
        println("parsing EuropeanItem")
    }
}

fun main(args: Array<String>) {
    val hashMap = HashMap<Class<out BaseItem>, ItemParser<*>>()
    hashMap.put(AmericanItem::class.java, EuropeanItemParser())
    hashMap.put(EuropeanItem::class.java, AmericanItemParser())

    val inputItem = EuropeanItem()
    val foundParser = hashMap[inputItem.javaClass]
    foundParser?.parse(inputItem)
}

My issue is at the very last line, when I am trying to invoke the parser, I am getting the following compilation error

Out-projected type 'ItemParser<*>?' prohibits the use of 'public abstract fun parse(item: T): kotlin.Unit defined in ItemParser'

What am I doing wrong here ?

kotlin generics
2 Answers

You have created a conflict between your declarations of the Map and of the ItemParser. The map can contain any descendant of BaseItem but the ItemParser is designed that each descendant only operates on one of the descendants of BaseItem. So for a given instance of ItemParser it must accept something it can recognize and here you can't do that because your foundParser could be any descendant and not the one true expected type for that given ItemParser instance. Which T should it guess at?!? It cannot.

Therefore you have to design your API around the base class and not the descendants. You make it impossible for the compiler to know what is be passed to the parse() method. The only one true thing you can know is that it is a BaseItem instance.

Only you know the trick you are doing with the map that guarantees you are calling the correct instance with the correct type. The compiler has no idea of your logic that makes that a guarantee.

I would suggest you change your API to add an internalParse method for which you cast do your work, wrapped by a generic parse function that double checks and does the evil cast.

abstract class BaseItem

class AmericanItem : BaseItem()
class EuropeanItem : BaseItem()

interface ItemParser<T: BaseItem> {
    @Suppress("UNCHECKED_CAST")
    fun parse(item: BaseItem) {
        val tempItem = item as? T 
             ?: throw IllegalArgumentException("Invalid type ${item.javaClass.name} passed to this parser")
        internalParse(tempItem)
    }

    fun internalParse(item: T)
}

class AmericanItemParser : ItemParser<AmericanItem> {
    override fun internalParse(item: AmericanItem) {
        println("AmericanItemParser")
    }
}

class EuropeanItemParser : ItemParser<EuropeanItem> {
    override fun internalParse(item: EuropeanItem) {
        println("parsing EuropeanItem")
    }
}

fun main(args: Array<String>) {
    val hashMap = HashMap<Class<out BaseItem>, ItemParser<*>>()
    hashMap.put(AmericanItem::class.java, EuropeanItemParser())
    hashMap.put(EuropeanItem::class.java, AmericanItemParser())

    val inputItem = EuropeanItem()
    val foundParser = hashMap[inputItem.javaClass]
    foundParser?.parse(inputItem)
}

Note you could also use the Kotlin class instead of the Java class which would be of type KClass<out T>.

user_36796760

ItemParser<*> is a parser of an unknown T rather than any T. Since that T is unknown, there's no value that you can safely pass to a function parse that expects T.

If you're sure that the map contains ItemParser<T> for a given Class<T> key, you can write the following helper function that uses an unchecked cast:

fun <T : BaseItem> Map<Class<out T>, ItemParser<*>>.findParserFor(item: T) =
    get(item.javaClass) as ItemParser<T>?

and then use it like:

val foundParser = hashMap.findParserFor(inputItem)
foundParser?.parse(inputItem)

Note that in your example the map associates AmericanItem::class.java key to EuropeanItemParser and vice versa

hashMap.put(AmericanItem::class.java, EuropeanItemParser())
hashMap.put(EuropeanItem::class.java, AmericanItemParser())

The code will fail due to an exception in run time:

ClassCastException: EuropeanItem cannot be cast to AmericanItem

The exception will happen when you pass EuropeanItem to parse() function, rather than in the findParserFor function. This happens because the returned ItemParser<EuropeanItem> instance is actually an AmericanItemParser. It is the result of using an unchecked cast assuming types will match when in fact they won't, and this is why that cast is called "unchecked".

user_8691840
Related