A modern programming language that makes developers happier.

kotlinlang

Will kotlin ever get proper generics (not the castrated jvm half-assed solution)?

I think you can do a lot of it already with `inline` + `reified`

reifeid doesn't do anything for class level generic parameters

I still need a
`abtract fun fooType() : Class<T>` to override in sublasses, don't I?

<https://openjdk.org/projects/valhalla/design-notes/in-defense-of-erasure|https://openjdk.org/projects/valhalla/design-notes/in-defense-of-erasure>

I'm sure there were reasons, but state of the matter is that it's lacking compared say to Swift

so I'm wondering if it's even possible to get rid of the java baggage

Erasure is probably going to be there for a long time, if not always, as long as interop with Java is a thing.

What are you trying to do, anyway? Do you have a longer snippet?

basically this

```class Screen<T> {
	fun createViewModel() {
		val scopes = Scopes.get(T::class) <----
		..
	}
}```

It's not the best but the typical pattern is

```inline fun &lt;reified T&gt; Screen() = Screen(T::class.java)

class Screen&lt;T&gt;(private val clazz: Class&lt;T&gt;) ...```

I should have given more context

this is android, I cannot have ctor parameters .. well I can but then they need to be serialized etc

Class is serializable so if the class is Serializable it should be fine. I believe Parcels can hold Serializable, so you should be fine if the class is Parcelable

not sure if it's worth the reflection runtime penalty :confused:

is there no way to trick it like this?

```class Screen&lt;T&gt; {
    fun foo() {
        
    }

    inline reified &lt;T&gt; whatever() -&gt; KClass&lt;T&gt; {
        T::class
    }
}```

I think that would be a different `T`, but if you want to specify `T` when you invoke `whatever` that would work (but would be brittle)

You might also have to do an unsafe cast

&gt; not sure if it's worth the reflection runtime penalty 
&gt; 
You mean `Class.forName` (if that's what deserialization is using)? Unless this is a critical section you're probably fine. Not even sure how big of a penalty it is.

<@U05TC8RRN5C> that was a really interesting reading, thanks for sharing!