Star projection for unknown types in Kotlin - Step-by-Step Execution

Concept Flow - Star projection for unknown types

Start with generic type T

↓

Unknown type encountered

↓

Apply star projection (*)

↓

Use projected type safely

↓

Compile and run without type errors

When Kotlin code encounters an unknown generic type, it uses star projection (*) to safely handle it without knowing the exact type.

Execution Sample

Kotlin

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

val mixedList: List<Any> = listOf(1, "two", 3.0)
printList(mixedList)

This code prints all items in a list of unknown type using star projection.

Execution Table

Step	Action	Type of list parameter	Item type inside loop	Output
1	Call printList with mixedList	List<*> (star projection)	Unknown (star projected)
2	Enter for loop, get first item	List<*>	Any? (1)	1
3	Print first item	List<*>	Any? (1)	1
4	Get second item	List<*>	Any? ("two")	two
5	Print second item	List<*>	Any? ("two")	two
6	Get third item	List<*>	Any? (3.0)	3.0
7	Print third item	List<*>	Any? (3.0)	3.0
8	End of list reached	List<*>	N/A	Loop ends

💡 All items printed; star projection allowed safe iteration without knowing exact type.

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
list	List<Any> (mixedList)	List<*>	List<*>	List<*>	List<*>
item	N/A	1 (Int)	"two" (String)	3.0 (Double)	N/A

Key Moments - 2 Insights

Why can we use List<*> instead of List<T> when the type is unknown?

List<*> means the type is unknown but safe to use; it lets us read items as Any? without type errors, as shown in execution_table rows 1-7.

Can we add items to a List<*>?

No, because the exact type is unknown, adding items is unsafe. The star projection only allows safe reading, not writing.

Visual Quiz - 3 Questions

Look at the execution_table at step 2, what is the type of the list parameter?

A List<Any>

B List<String>

C List<*>

D List<Int>

💡 Hint

Check the 'Type of list parameter' column at step 2 in execution_table.

At which step does the loop finish iterating over all items?

A Step 6

B Step 8

C Step 7

D Step 5

💡 Hint

Look for the 'End of list reached' action in execution_table.

If we tried to add an item to the list inside printList, what would happen?

A It would cause a compile-time error.

B It would compile and add the item safely.

C It would add the item but cause runtime error.

D It would ignore the add operation.

💡 Hint

Recall key_moments about adding items to List<*>.

Concept Snapshot

Star projection (*) in Kotlin means unknown generic type.
Use List<*> to handle lists when type is unknown.
You can read items as Any?, but cannot add items.
Safe way to work with generics without exact type.
Common in APIs and libraries for flexibility.

Full Transcript

This visual trace shows how Kotlin uses star projection (*) to handle unknown generic types safely. When a function takes a List<*>, it means the list's element type is unknown. The code can safely read items as Any? but cannot add new items. The execution table walks through calling printList with a mixed list of Int, String, and Double. Each item is printed without type errors. The variable tracker shows how the list parameter is treated as List<*> and items are read one by one. Key moments clarify why star projection allows safe reading but forbids adding. The quiz tests understanding of the type at each step and the limitations of star projection. The snapshot summarizes star projection as a safe way to handle unknown generic types in Kotlin.