https://kotlinlang.org logo
Join Slack
Powered by
In my experience,`as?` or `as` doesn't seem to wor...
# announcements
c
In my experience,
as?
or 
as
doesn't seem to work when using them with generic 
T: KClass<out Any>
. For example 
someClass as T
will return 
someClass
, even when 
T
is not `someClass`'s ancestor. if anyone could put an eye on the code in the comment to this, that would be great! Currently, in trying to achieve 
instanceof
-like behavior, my method returns 
true
for 
Nothing::class instanceof Number::class
and I wish I was joking 🤖 . I've been trying to figure this out for maybe 3 hours now?If I'm using generics properly, then 
as
and 
as?
are broken when used with generics?
Copy code
infix fun <PossibleSuperClass> KClass<out Any>.instanceof(clazz: PossibleSuperClass)
        : Boolean where PossibleSuperClass : KClass<out Any> {
    return try {
        this as PossibleSuperClass
        true
    } catch (e: ClassCastException) {
        false
    }
}
Same happens if i go the 
as?
way. My hunch is there's issues with 
PossibleSuperClass
. When debugging, `this`/`$receiver` is 
java.lang.Void
, 
clazz
is 
kotlin.Number
, and 
this as PossibleSuperClass
returns `this`s value, 
java.lang.void
in this case (???). The value of 
this
is returned every time even when an exception should be thrown or 
null
should be returned
c
Probably a simple consequence of erased generics
c
Can I unerase it/them?
c
Somewhat, with 
reified
. But the code you pasted above is scary
k
what are you trying to check there? 
Nothing::class is Number::class
wouldn't even work
you could do 
Nothing::class is Number
which will return false, because you're checking if a 
KClass
object is an instance of 
Number
, which it isn't
c
I'm just trying to check if a class a is a subclass of b
reverse behavior of java class isAssignableFrom
k
you can't do that with 
is
or 
instanceof
. In Java that's something like 
Foo.class.isAssignableTo(Bar.class)
I believe
c
Are you working with classes or values? If the former, 
isAssignableFrom
is probably what you want
k
assignableFrom, yeah
c
I wanted a java-agnostic way of doing this 😞
k
KClass should have a method for that, probably
c
If you want the reverse of 
isAssignableFrom
, just reverse the arguments
c
I want it but kotlin-code only. I was at the 
isAssignableFrom
an hour and something ago
c
value::class.java.isAssignableFrom...
k
hm yeah, I don't see anything on 
KClass
like 
isAssignableFrom
c
Think I found a way kotlin-only
let me run the debugger!
c
Just run the REPL
c
Copy code
infix fun <PossibleSuperClass> KClass<out Any>.instanceof(clazz: PossibleSuperClass)
        : Boolean where PossibleSuperClass : KClass<out Any> {
    return clazz.nestedClasses.contains(this)
}
oh wait, maybe that's something else, thought it was a metaphorical 
nestedClass
, like nested inside the inheritance hierarchy of the class
k
that isn't what you want, yeah
c
Copy code
infix fun <PossibleSuperClass> KClass<out Any>.instanceof(clazz: PossibleSuperClass)
        : Boolean where PossibleSuperClass : KClass<out Any> {
    return clazz.isInstance(this)
}
k
are you expecting 
Int::class instanceof Number::class
to return true there?
c
But if you end up processing classes in a programmatic way, you can't use 
as
or 
as?
anymore
assuming 
Int : Number
, i hope so
k
it won't, because you're asking if 
KClass<Number>
is an instance of 
Int
Int::class.isInstance(3)
would be true
Int::class.isInstance(Number::class)
would not
KClass::class.isInstance(Number::class)
would be true
because 
Number::class
is a 
KClass<Number>
, which makes it an instance of 
KClass
c
ok but then there isn't a way I guess?
k
you could manually write a function that checks 
superTypes
recursively maybe
There's 
allSupertypes
that flattens out the hierarchy for you into one list, but it's JVM-only, haha
c
Hmm, I'll try with 
superTypes
, thanks for the idea. Maybe I can figure it out without JVM after all!
Thanks for the idea, found out about 
KClass#starProjectedType
which returns 
KType
, which has 
isSubtypeOf
. Method is
Copy code
infix fun <PossibleSuperClass> KClass<out Any>.instanceof(clazz: PossibleSuperClass)
        : Boolean where PossibleSuperClass : KClass<out Any> {
    return this.starProjectedType.isSubtypeOf(clazz.starProjectedType)
}
And the checks

https://i.imgur.com/uLNxG3Z.pngâ–¾

m
What's the point of doing this in pure Kotlin? Neither of the other targets support the required reflection mechanisms so you'll be bound to the JVM anyway.
c
Won't Kotlin ship with it's own VM eventually?
VM that will hopefully implement natively the api at the time?
m
Haven't seen anyone say that's a goal. Source?
Pretty sure someone from Kotlin/Native explicitly said they aren't looking to add their own VM to that so would have to be a new target.
c
Hmm, okay, maybe 
Kotlin/Native
is what I meant, forget about the VM thing. But Kotlin/Native would still have to implement stuff like 
KType
and its functions, right?
c
I’m still not sure what you’re trying to achieve that’s not already covered by 
is
and 
as
c
Or is 
KType
a Kotlin class used as an umbrella thing just for Kotlin + JVM together?
k
@cedric he's trying to determine if one 
KClass
instance is a supertype of another, basically
c
Cedric, if I try to use 
x is y::class
or through the type, it complains. if 
y : KType
and try 
x is y
it complains, it only works with Real Types, like 
OutOfMemoryException
, not 
platformUiException::class
k
is
and 
as
cover it when you know the types statically
c
yes, I guess 
static types
better describes it
k
these are dynamic class instances so if I'm understanding his problem correctly, it's exactly why you can't do something like
Copy code
Class<?> type = Foo.class;
if (myFoo instanceof type) { ... }
in Java
c
Ah ok
k
unfortunately there's no platform-agnostic 
myKClass.isAssignableFrom(otherKClass)
, you have to go through the 
.java
extension and get a regular 
Class
instance for that
c
The thing I posted seemed to work, is that interracting with the JVM? Only uses 
KClass
and 
KType
Copy code
// e.g. object::class instanceof Activity::class
infix fun <PossibleSuperClass> KClass<out Any>.instanceof(clazz: PossibleSuperClass)
        : Boolean where PossibleSuperClass : KClass<out Any> {
    return this.starProjectedType.isSubtypeOf(clazz.starProjectedType)
}

// e.g. object instanceof Activity::class
infix fun <PossibleSuperClass> Any.instanceof(clazz: PossibleSuperClass)
        : Boolean where PossibleSuperClass : KClass<out Any> {
    return this::class instanceof clazz
}
m
c
Alright, but we have 
KClass#superTypes : List<KType>
which we could use instead 🤔 Flatmap it to a boolean maybe?
g
@ClaudiuB Such thing that you trying to implement make sense, but not sure that it will work on K/N, maybe you should ask in #C3SGXARS6 about real platform agnostic solution or just open an issue about this case
3 Views
Open in Slack
PreviousNext
Powered by