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.

Practice

1. What does the star projection * represent in Kotlin generics?

easy

A. A type that can only be used with primitive data types

B. A specific generic type that must be defined explicitly

C. A wildcard that allows writing but restricts reading

D. An unknown generic type that allows safe reading but restricts writing

Solution

1. Step 1: Understand star projection meaning

   The star projection * means an unknown generic type in Kotlin.

2. Step 2: Analyze its usage

   It allows safe reading from generic collections but restricts writing to avoid type errors.

3. Final Answer:

   An unknown generic type that allows safe reading but restricts writing -> Option D

4. Quick Check:

   Star projection = unknown generic type with safe read [OK]

Hint: Star projection means unknown type, safe read only [OK]

Common Mistakes:

• Thinking star projection allows writing to generics
• Confusing star projection with specific generic types
• Assuming star projection only works with primitives

2. Which of the following is the correct syntax to declare a list with star projection in Kotlin?

easy

A. val list: List<Any> = listOf(1, 2, 3)

B. val list: List<*> = listOf(1, 2, 3)

C. val list: List<> = listOf(1, 2, 3)

D. val list: List = listOf(1, 2, 3)

Solution

1. Step 1: Recall star projection syntax

   Star projection uses * inside angle brackets to represent unknown type.

2. Step 2: Check each option

   val list: List<*> = listOf(1, 2, 3) uses List<*> which is correct syntax for star projection.

3. Final Answer:

   val list: List<*> = listOf(1, 2, 3) -> Option B

4. Quick Check:

   Star projection syntax = List<*> [OK]

Hint: Star projection syntax always uses * inside angle brackets [OK]

Common Mistakes:

• Leaving angle brackets empty like List<>
• Using List<Any> which is not star projection
• Confusing star projection with out-projection

3. What will be the output of the following Kotlin code?

fun printFirst(list: List<*>) {
    println(list[0])
}

fun main() {
    val numbers: List<Int> = listOf(10, 20, 30)
    printFirst(numbers)
}

medium

A. 10

B. Compilation error

C. null

D. Runtime exception

Solution

1. Step 1: Understand star projection usage in function

   The function accepts List<*>, meaning unknown generic type, safe to read elements.

2. Step 2: Analyze the call with List<Int>

   Passing List<Int> is valid; reading list[0] returns 10 safely.

3. Final Answer:

   10 -> Option A

4. Quick Check:

   Reading from List<*> returns element safely [OK]

Hint: Reading from List<*> works, writing does not [OK]

Common Mistakes:

• Assuming star projection causes compile error
• Expecting null instead of actual element
• Thinking runtime exception occurs on read

4. Identify the error in the following Kotlin code using star projection:

fun addElement(list: MutableList<*>, element: Any) {
    list.add(element)
}

medium

A. Element type Any is incompatible with list

B. Syntax error in function declaration

C. Cannot add element to MutableList<*> due to unknown type

D. No error, code compiles and runs fine

Solution

1. Step 1: Understand star projection with MutableList

   MutableList<*> means unknown generic type; writing is restricted to avoid type errors.

2. Step 2: Analyze the add operation

   Trying to add element causes compile error because type is unknown and unsafe to write.

3. Final Answer:

   Cannot add element to MutableList<*> due to unknown type -> Option C

4. Quick Check:

   Writing to MutableList<*> causes error [OK]

Hint: Cannot write to star-projected mutable collections [OK]

Common Mistakes:

• Thinking add works with MutableList<*>
• Confusing syntax error with type error
• Assuming Any type is always accepted

5. Given a function that accepts a list with star projection, how can you safely copy elements from List<*> to a MutableList<Any> in Kotlin?

hard

A. Use a loop to cast each element to Any and add to MutableList<Any>

B. Directly assign List<*> to MutableList<Any>

C. Use star projection on both lists

D. Use MutableList<*> instead of MutableList<Any>

Solution

1. Step 1: Understand star projection restrictions

   List<*> allows safe reading but elements are of unknown type, so direct assignment to MutableList<Any> is unsafe.

2. Step 2: Safely copy elements

   Use a loop to read each element and cast to Any before adding to MutableList<Any>, ensuring type safety.

3. Final Answer:

   Use a loop to cast each element to Any and add to MutableList<Any> -> Option A

4. Quick Check:

   Copy with loop and cast = safe transfer [OK]

Hint: Copy elements with loop and cast from List<*> to MutableList<Any> [OK]

Common Mistakes:

• Trying direct assignment between incompatible generic types
• Using star projection on mutable list incorrectly
• Ignoring type casting when copying elements