Star projection for unknown types in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of star projection with unknown generic type

What is the output of this Kotlin code using star projection on a generic list?

Kotlin

fun printList(list: List<*>) {
    for (item in list) {
        println(item)
    }
}

fun main() {
    val mixedList: List<Any?> = listOf(1, "two", 3.0, null)
    printList(mixedList)
}

A Runtime exception due to star projection

B 1\ntwo\n3.0\nnull

C 1\ntwo\n3.0

D Compilation error due to unknown type

💡 Hint

Star projection allows reading elements as type Any?, so printing works fine.

The star projection List<*> means the list can hold elements of unknown type, but you can safely read elements as Any?. The code prints all elements including null.

🧠 Conceptual

intermediate

Understanding star projection type safety

Which statement about Kotlin star projection (e.g., List<*>) is correct?

A You can only read elements as type Any? from a List<*>.

B You can add elements of any type to a List<*> safely.

C List<*> is equivalent to List<Any>.

D List<*> allows casting elements to their original type without checks.

💡 Hint

Think about what operations are safe when the exact generic type is unknown.

Star projection means the generic type is unknown, so you cannot add elements safely, but you can read elements as Any?.

🔧 Debug

advanced

Why does this code cause a compilation error?

Consider this Kotlin code snippet: fun addElement(list: MutableList<*>, element: Any) { list.add(element) } Why does this code fail to compile?

A Because MutableList<*> does not allow adding elements due to unknown generic type.

B Because element is of type Any, which is incompatible with MutableList<*>.

C Because add() requires a nullable type but element is non-nullable.

D Because MutableList<*> is immutable and does not have add() method.

💡 Hint

Think about what star projection means for mutable collections.

MutableList<*> means the element type is unknown, so adding any element is unsafe and disallowed by the compiler.

📝 Syntax

advanced

Correct syntax for star projection in Kotlin

Which of the following is the correct way to declare a function parameter using star projection for a generic type?

A fun process(items: List<?>) { /*...*/ }

B fun process(items: List<Any>) { /*...*/ }

C fun process(items: List<*>) { /*...*/ }

D fun process(items: List<out Any>) { /*...*/ }

💡 Hint

Kotlin uses star (*) for unknown generic types, not question marks.

Kotlin uses star projection syntax List<*> to represent unknown generic types. List is Java syntax and invalid in Kotlin.

🚀 Application

expert

Using star projection to safely print elements of unknown generic type

You have a function that accepts a List with an unknown generic type. You want to print all elements safely without causing type errors. Which code snippet correctly uses star projection to achieve this?

A

fun printElements(list: List<Any?>) {
    for (item in list) {
        println(item)
    }
}

B

fun printElements(list: List<Any>) {
    for (item in list) {
        println(item)
    }
}

C

fun printElements(list: List<out Any>) {
    for (item in list) {
        println(item)
    }
}

D

fun printElements(list: List<*>) {
    for (item in list) {
        println(item)
    }
}

💡 Hint

Star projection allows reading elements as Any? regardless of the unknown type.

List<*> means the generic type is unknown but elements can be read as Any?, so printing them is safe.