Because a single converter instance can convert mu...

# klaxon

[karelpeeters]

Because a single converter instance can convert multiple different types.

[aleksandrsl]

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") 
    }
}

[karelpeeters]

But what about the canConvert function then?

[karelpeeters]

And if you add that you might as well remove the illusion of type safety entirely.

[aleksandrsl]

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

[karelpeeters]

Is that how you implement that method? Its supposed to be ... = cls == MyType::class or something like that.

[karelpeeters]

Or for multiple types = cls == MyType::class.java || cls == MyOtherType::class.java.

[aleksandrsl]

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

[karelpeeters]

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

[karelpeeters]

For custom converter implementations you usually don't do that

[aleksandrsl]

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)

[karelpeeters]

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

[cedric]

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