Does anyone know whether this is possible using reflection only?

(person::class.companionObjectInstance as PersonDTO.Companion)

(person is an instance of PersonDTO)

What do you mean by “using reflection only”?

I have an interface `Validateable`:

interface Validateable<T> {
    val validator: Validation<T>
}

I implement this interface on my class's companion object:

@Serializable
data class PersonDTO(val id: Long? = null, val name: String, var age: Int) {
    companion object : Validateable<PersonDTO> {
        override val validator = Validation<PersonDTO> {
            PersonDTO::age{
                minimum(0)
            }
        }
    }
}

When processing requests on the backend, I would like to (dynamically) check whether the body's (which is an instance) companion object implements the

Validateable

interface. I have tried this:

val person = PersonDTO(null, "test", -24)
    val companion = person::class.companionObjectInstance
    if(companion is Validateable<*>){
        companion.validator(person)
    }

But this gives me the following error:

Out-projected type 'Validation<out Any?>' prohibits the use of public open operator fun invoke(value: T): ValidationResult<T> defined in io.konform.validation.Validation

You should think more Kotlin I guess. But you want to use reflection hmm

Sadly that nets me the same error 😔 (when using the following code)

val person = PersonDTO(null, "test", -24)
    val companion = person::class.companionObjectInstance
    if (companion is Validator<*>) {
        companion.validate(person)
    }

The code you show doesn’t match what I wrote at all

That's when calling the validate function, this is my model class at the moment:

@Serializable
data class PersonDTO(val id: Long? = null, val name: String, var age: Int) : Validateable<PersonDTO> {
    companion object : Validator<PersonDTO> {
        override fun validate(m: PersonDTO): ValidationResult<PersonDTO> {
            return validator.validate(m)
        }
        
        val validator = Validation<PersonDTO> {
            PersonDTO::age{
                minimum(0)
            }
        }
    }
}

I think your problem is

if (companion is Validator<*>) {

I end up doing the following. Interface:

interface Validateable<T>{
   fun validate(): ValidationResult<T>
}

DTO:

@Serializable
data class PersonDTO(val id: Long? = null, val name: String, var age: Int) : Validateable<PersonDTO> {
    override fun validate() = validator.validate(this)

    private companion object {
        val validator = Validation<PersonDTO> {
            PersonDTO::age{
                minimum(0)
            }
        }
    }
}

This allows me to validate my objects as follows:

if (o is Validateable<*>) {
        o.validate()
    }