How can I do something like this? ```fun isClass(theObject : Any, theClass : KClass) : Boolean { ...

# getting-started

[Daniele B]

How can I do something like this?

fun isClass(theObject : Any, theClass : KClass) : Boolean {
    if (theObject is theClass) {
        return true
    }
    return false
}

I would like to use it in this way:

val verification = isClass(myObject, Person::class)

[acoconut]

val verification = myObject is Person

[Roukanken]

you should use it directly like that ↑

but if you need to group it with some other validation or smth you can use reified inline functions

inline fun <reified T> isClass(theObject: Any): Boolean {
    // some other logic
    return theObject is T
}


val obj: Any = "Some string"
val verification = isClass<String>(obj)

DO NOT use it if you just want to do the simple check, as the is operator is way more readable. So use this only if you need to do some additional logic, or call some additional functions...

[Daniele B]

I need to pass the Class::class to the function, because there is some processing I need to do with this information

[Roukanken]

in the reified function, you can use T::class

[Daniele B]

I found out I can pass it like KClass<*>

fun getFromAppState(theClass : KClass<*>) : Any? {
}

[Daniele B]

and then:

if (theClass.isInstance(obj)) {
    ...
}

[kqr]

theClass.isInstance?

[Daniele B]

yes, that was what I was looking for

[Daniele B]

so, in summary, the original function would be:

fun isClass(theObject : Any, theClass : KClass<*>) : Boolean {
    if (theClass.isInstance(theObject)) {
        return true
    }
    return false
}

[Roukanken]

you can do the same thing with the reified function 😛

fun someOtherLogic(theClass: KClass<*>): Unit = TODO()

inline fun <reified T> isClass(theObject: Any): Boolean {
    someOtherLogic(T::class)
    return theObject is T
}

val obj: Any = "Some string"
val verification = isClass<String>(obj)

like this - the call, after the function is inlined would look like:

val obj: Any = "Some string"
someOtherLogic(String::class)
val verification = obj is String

[Daniele B]

thanks! is there any particular advantage in using a reified function, or is it just a matter of taste?

[Roukanken]

advantage is mostly in api while calling it
a) you don't have to do ::class while calling it everywhere
b) if the type can be inferred, you don't need to specify it at all (which is probably not case here tho)

[Roukanken]

eg, I'm sure you ran into some reflection functions that have signatures like

fun <T> someWork(theObject: T, theClass: KClass<T>): Unit = TODO()

when you calling them you need to repeat yourself:

val x: String = "abc"
someWork(x, String::class)

[Roukanken]

if you had an reified function to accompany it, (which thankfully most Kotlin reflection libraries do)

inline fun <reified T> someWork(theObject: T): Unit {
    someWork(theObject, T::class)
}

you can simply call it:

val x: String = "abc"
someWork(x)

[Roukanken]

(since it will infer that to someWork<String>(x) automatically)

[Daniele B]

yes, it makes sense
However in some use cases you don’t have an instance to pass, you just want to pass the class. In such case KClass<*> is very handy.

[Daniele B]

I just found out KClass<T> exists too, that is very handy, and yes, it requires “reified”