Because a single converter instance can convert multiple different types.

Can't we just use implementation parametrized with

Any

in this case (e.g.

DefaultConverter

), and we will have types in other cases?

import com.beust.klaxon.JsonValue

interface Test<T> {
    
    fun fromJson(jv: JsonValue): T
    
    fun toJson(value: T): JsonValue
}

class TestImpl: Test<Any> {
    override fun fromJson(jv: JsonValue): Any {
        TODO("not implemented")
    }

    override fun toJson(value: Any): JsonValue {
        TODO("not implemented") 
    }
}

But what about the

canConvert

function then?

override fun canConvert(cls: Class<*>) = true

seems absurd too. With generic interface you can create custom converter that returns object of concrete class, I see type safety here

Is that how you implement that method? Its supposed to be

... = cls == MyType::class

or something like that.

Nope, not mine implementation, this one https://github.com/cbeust/klaxon/blob/master/src/main/kotlin/com/beust/klaxon/DefaultConverter.kt#L14

Well that's a special case since it's the fallback one, but it's indeed strange that it returns

true

.

Thanks for clarification) however it seems somewhat strange that you're writing converter that creates objects of single class and after convertion you must to cast this object. Need time to reconcile with this)

If you want you can write a wrapper abstract class that takes in the correct class and then places more restrictions on the functions.

FYI, I went back and forth between making the converter generic or not, and it was generic in the previous version of Klaxon. However, I decided that the current implementation is more flexible