Star Projection

fun printSize(value: Any) {
    if (value is List<*>) {
        println("List size: ${value.size}")
    }
}

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

fun printAll(items: List<*>) {
    for (item in items) {
        println(item)
    }
}

fun main() {
    printAll(listOf(1, "two", 3.0))
}

fun describeMutable(list: MutableList<*>) {
    // list.add("something") would not compile here
    println("A mutable list with ${list.size} elements of an unknown type")
}

fun main() {
    val numbers = mutableListOf(1, 2, 3)
    describeMutable(numbers)
}

fun sumConcrete(numbers: List<Int>): Int = numbers.sum()

fun main() {
    println(sumConcrete(listOf(1, 2, 3, 4)))
}

1. Trying to add an element to a MutableList<*>, which the compiler rejects since the actual element type is unknown, so nothing can be safely inserted.
2. Confusing List<*> with List<Any?>; a star projection is more restrictive because it also blocks unsafe writes, while List<Any?> allows adding any value.
3. Overusing star projection when the actual type parameter is already known and a concrete generic type would be clearer and safer.

• Type<*> (a star projection) represents a generic type when the exact type argument is unknown or unimportant.
• A star-projected generic type allows safe reading (of a supertype like Any?) but disallows writing, since the compiler cannot verify type safety for insertion.
• Star projection is commonly used in is checks, like is List<*>, since erasure prevents checking the actual element type.
• List<*> behaves like a read-only list of unknown element type, distinct from List<Any?> which explicitly allows any type.