> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Kotlin Star Projection Star projection (`*`) is a type projection syntax in Kotlin used to represent an unknown type argument within a generic type. It acts as a type-safe equivalent to Java's unbounded wildcards (``), allowing developers to reference a generic type without specifying its exact type parameter, while the compiler strictly enforces type safety based on the parameter's declaration-site variance. When a generic type is instantiated with a star projection, the Kotlin compiler automatically resolves the allowed read and write operations by mapping the `*` to specific `in` (contravariant) and `out` (covariant) projections. ## Runtime Type Checking and Type Erasure A fundamental application of star projections is performing runtime type checks. Because Kotlin erases generic type arguments at runtime (type erasure), it is impossible to check if an object is an instance of a generic type with a specific type argument. Attempting to do so results in a compiler error. Star projections provide the required mechanism to safely check the base type at runtime. ```kotlin theme={"dark"} fun checkType(obj: Any) { // if (obj is List) { ... } // Compilation error: Cannot check for instance of erased type if (obj is List<*>) { // Allowed: Checks if obj is a List of some unknown type println("Object is a List of size ${obj.size}") } } ``` ## Variance Resolution Rules The behavior of a star-projected type depends entirely on how the generic type parameter was originally declared. ### 1. Covariant Declaration (`out T`) If a type parameter is declared as covariant, the star projection allows reading the upper bound of `T`, but prohibits writing. * **Declaration:** `interface Producer` * **Star Projection:** `Producer<*>` * **Compiler Interpretation:** `Producer` * **Behavior:** You can safely read values of type `Any?` from the object, but you cannot pass any values to methods that expect `T`. ```kotlin theme={"dark"} interface Producer { fun produce(): T } fun testProducer(producer: Producer<*>) { val item: Any? = producer.produce() // Allowed: Reads as Any? } ``` ### 2. Contravariant Declaration (`in T`) If a type parameter is declared as contravariant, the star projection prevents writing any value to the object, as the exact accepted type is unknown. * **Declaration:** `interface Consumer` * **Star Projection:** `Consumer<*>` * **Compiler Interpretation:** `Consumer` * **Behavior:** You cannot safely write *any* value to methods expecting `T` (because the `Nothing` type has no instances). ```kotlin theme={"dark"} interface Consumer { fun consume(item: T) } fun testConsumer(consumer: Consumer<*>) { // consumer.consume("test") // Compilation error: Expected Nothing } ``` ### 3. Invariant Declaration (`T`) If a type parameter is invariant (neither `in` nor `out`), the star projection splits the behavior for reading and writing. * **Declaration:** `interface MutableBox` * **Star Projection:** `MutableBox<*>` * **Compiler Interpretation:** `MutableBox` for reading, `MutableBox` for writing. * **Behavior:** You can read values as `Any?`, but you cannot write any values. ```kotlin theme={"dark"} interface MutableBox { fun get(): T fun set(value: T) } fun testBox(box: MutableBox<*>) { val item: Any? = box.get() // Allowed: Reads as Any? // box.set("test") // Compilation error: Expected Nothing } ``` ### 4. Type Parameters with Upper Bounds If the generic type parameter has a defined upper bound other than `Any?`, the star projection respects that bound during covariant reads. * **Declaration:** `interface BoundBox` * **Star Projection:** `BoundBox<*>` * **Compiler Interpretation:** `BoundBox` for reading, `BoundBox` for writing. ```kotlin theme={"dark"} interface BoundBox { fun get(): T } fun testBoundBox(boundBox: BoundBox<*>) { val item: CharSequence = boundBox.get() // Allowed: Reads as CharSequence } ``` ## Multiple Type Parameters For types with multiple generic parameters, each parameter can be star-projected independently. The compiler resolves each `*` according to its specific declaration. ```kotlin theme={"dark"} interface Function { fun apply(arg: T): U } fun testFunctions( f1: Function<*, String>, // Resolves to Function f2: Function, // Resolves to Function f3: Function<*, *> // Resolves to Function ) { // Implementation omitted } ```

Tired of Poor Kotlin Skills? Fix That With Deep Grasping! Learn More