Type Erasure

fun main() {
    val strings: List<Any> = listOf("a", "b")
    val numbers: List<Any> = listOf(1, 2)
    println("Same runtime class: ${strings::class == numbers::class}")
}

fun describe(value: Any) {
    if (value is List<*>) {
        println("It is some kind of List with ${value.size} elements")
    }
}

fun main() {
    describe(listOf(1, 2, 3))
    describe(listOf("a", "b"))
}

inline fun <reified T> countOfType(items: List<Any>): Int = items.count { it is T }

fun main() {
    val mixed = listOf(1, "a", 2, "b", 3)
    println("Number of Strings: ${countOfType<String>(mixed)}")
}

fun main() {
    val stringArray: Array<String> = arrayOf("a", "b")
    println("Array component type: ${stringArray.javaClass.componentType}")
}

1. Trying to check if (list is List<String>), which the compiler rejects since the element type is erased and cannot be checked at runtime.
2. Assuming two List<Int> and List<String> are different runtime classes; at runtime they are both simply the same List class.
3. Forgetting that arrays are an exception -- unlike generic collections, arrays retain their element type information at runtime (reified natively by the JVM).

• At runtime, generic type parameters are erased -- a List<String> and a List<Int> are both just List once compiled.
• You cannot check is List<String> directly; only an unchecked cast or a star-projected check like is List<*> is allowed.
• Type erasure is a JVM-wide limitation, not specific to Kotlin, and it's why reified type parameters (with inline) exist as a workaround.
• Arrays are an exception to erasure -- their component type is preserved by the JVM at runtime.