A modern programming language that makes developers happier.

kotlinlang

Why isn’t this legal?
```
class Foo&lt;Bar&gt;(
        initial: Bar?
) {
    
    private val internal: Any? = initial
    
    fun baz(): Bar? {
        val i = internal
        return if (i is Bar) i
        else null
    }
}
```

&gt; *Error:* Cannot check for instance of erased type: Bar

The actual type of `Bar` is not retained at runtime. `Foo&lt;Int&gt;` and `Foo&lt;String&gt;` are the same class at runtime. So you cannot know what the actual type of `Bar` is.

But won’t it throw a ClassCastException if I use `as!! Bar` and it’s not a `Bar`?

First of all there is no `as!!`. And no. It can't. It will create a warning ("Unchecked cast"). What you then have is called heap pollution. You will get the class cast exception at some point down the line when someone actually tries to use the object as it's true type.

Oh I think I was confusing Swift again XD
They have an `as`, `as?` and `as!`

So is this a JVM problem? Because I know that Kotlin/JS has been very responsible about encoding types into objects

I'll give you an example:
```
val listOfStrings = mutableListOf&lt;String&gt;("Hello")
doEvilStuff(listOfStrings, 1)
println(listOfStrings[1]) // will crash, Int is not a String

fun &lt;T&gt; doEvilStuff(list: MutableList&lt;T&gt;, number: Int) {
    list += number as T // will not crash, because this method does not know what `T` is!
}
```

Bluh. It totally should. If I were designing it, that would compile into a method that takes another argument which is the declared generic class type, and throw an exception immediately if that type is not correct.

You can opt-in to that by using `reified` keyword with `inline` function.

Also, this is why there is the "unchecked" warning :wink:

But nothing like that is available for classes?

No. You'd have to pass in the class manually for example as `Class&lt;Bar&gt;` or `KClass&lt;Bar&gt;`

You can't have a `KClass` of a nullable type.

Because if it doesn't, then it's implicit upper bound is `Any?`, which is definitely nullable.

Back to my SSCCE:
```
class Foo&lt;Bar&gt;(
        initial: Bar?,
        val barClass: KClass&lt;Bar&gt;
) {

    private val internal: Any? = initial

    fun baz(): Bar? {
        val i = internal
        return if (i is Bar) i
        else null
    }
}
```

&gt; Type argument is not within its bounds
&gt; Expected: Any
&gt; Found:      Bar

Ah, so I change `Foo&lt;Bar&gt;` to `Foo&lt;Bar: Any&gt;`

I suppose I still internalize `?` as “wrapped in an `Optional`”

It’s hard switching so rapidly back and forth between Kt and Swift