In variance (contravariance) in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kotlin code using contravariance?

Consider the following Kotlin code snippet. What will be printed when it runs?

Kotlin

interface Consumer<in T> {
    fun consume(item: T)
}

class StringConsumer : Consumer<String> {
    override fun consume(item: String) {
        println("Consumed: $item")
    }
}

fun feedConsumer(consumer: Consumer<Any>) {
    consumer.consume(123)
}

fun main() {
    val stringConsumer: Consumer<String> = StringConsumer()
    feedConsumer(stringConsumer)
}

A Type mismatch error at compile time

B Consumed: 123

C Consumed: StringConsumer@<hashcode>

D Runtime exception: ClassCastException

💡 Hint

Think about how contravariance affects type compatibility in Kotlin generics.

The function feedConsumer expects a Consumer<Any>. However, stringConsumer is a Consumer<String>. Since Consumer is declared with in T (contravariant), Consumer<Any> is a subtype of Consumer<String>, not the other way around. Passing Consumer<String> where Consumer<Any> is expected causes a compile-time type mismatch error.

🧠 Conceptual

intermediate

Which statement correctly describes contravariance in Kotlin?

Choose the correct statement about contravariance in Kotlin generics.

A Contravariance allows a generic type to accept subtypes of its type parameter.

B Contravariance means the generic type parameter is covariant and can only produce values.

C Contravariance means the generic type parameter is invariant and cannot vary.

D Contravariance allows a generic type to accept supertypes of its type parameter.

💡 Hint

Think about the direction of type substitution allowed by 'in' keyword.

Contravariance in Kotlin is declared with the in keyword. It means the generic type can accept supertypes of its type parameter. For example, Consumer<in T> can consume objects of type T or any subtype, but it can be assigned to a variable expecting Consumer<SuperType>.

🔧 Debug

advanced

Why does this Kotlin code cause a compilation error?

Examine the Kotlin code below. Why does it fail to compile?

Kotlin

interface Producer<out T> {
    fun produce(): T
}

fun useProducer(producer: Producer<String>) {
    val anyProducer: Producer<Any> = producer
    println(anyProducer.produce())
}

fun main() {
    val stringProducer: Producer<String> = object : Producer<String> {
        override fun produce() = "Hello"
    }
    useProducer(stringProducer)
}

A Because Producer is covariant, assigning Producer<String> to Producer<Any> is invalid.

B Because Producer is contravariant, assigning Producer<String> to Producer<Any> is invalid.

C Because Producer is covariant, assigning Producer<String> to Producer<Any> is valid and compiles.

D Because Producer is contravariant, assigning Producer<String> to Producer<Any> is valid and compiles.

💡 Hint

Recall the meaning of 'out' keyword in Kotlin generics.

The Producer interface is declared with out T, making it covariant. This means Producer<String> is a subtype of Producer<Any>. Therefore, assigning producer of type Producer<String> to anyProducer of type Producer<Any> is valid and compiles.

📝 Syntax

advanced

Which Kotlin declaration correctly defines a contravariant generic interface?

Select the correct Kotlin interface declaration that uses contravariance.

A interface Consumer<out T> { fun consume(item: T) }

B interface Consumer<in T> { fun consume(item: T) }

C interface Consumer<T> { fun consume(item: T) }

D interface Consumer<in T> { fun produce(): T }

💡 Hint

Contravariant types use the 'in' keyword and can only consume values of type T.

Contravariance is declared with in in Kotlin. The interface Consumer<in T> can only consume (accept) values of type T. Option B correctly declares this. Option B uses out which is covariance. Option B is invariant. Option B is invalid because a contravariant type cannot produce values of type T.

🚀 Application

expert

How to safely assign a contravariant consumer in Kotlin?

Given the interface Consumer<in T>, which assignment is valid and safe in Kotlin?

Kotlin

interface Consumer<in T> {
    fun consume(item: T)
}

class AnyConsumer : Consumer<Any> {
    override fun consume(item: Any) {
        println("Consumed: $item")
    }
}

fun main() {
    val anyConsumer = AnyConsumer()
    // Which assignment below is valid?
    val stringConsumer: Consumer<String> = ???
}

A anyConsumer

B Consumer<Any>()

C Consumer<String>()

D null

💡 Hint

Remember contravariance allows assigning Consumer to Consumer.

Because Consumer is contravariant in T (declared with in T), Consumer<Any> can be assigned to Consumer<String>. This means anyConsumer of type Consumer<Any> can be assigned to stringConsumer of type Consumer<String>. This is safe because anyConsumer can consume any object, including Strings.