Out variance (covariance) in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does out keyword mean in Kotlin generics?

The out keyword means the generic type is covariant. It can only be returned (produced) but not consumed (accepted as input). This ensures type safety when using subtypes.

beginner

Why is covariance useful in Kotlin?

Covariance allows you to use a subtype where a supertype is expected, especially for read-only data. For example, a List<Dog> can be used as a List<Animal> if the list is covariant.

intermediate

Given interface Producer<out T>, can you pass T as a function parameter inside this interface?

No. Because T is declared with out, it can only be returned (produced), not consumed as input parameters. This prevents type errors.

intermediate

How does Kotlin enforce covariance at compile time?

Kotlin restricts usage of the covariant type parameter to only output positions (like return types). If you try to use it as an input parameter, the compiler will show an error.

intermediate

What is the difference between out and in variance in Kotlin?

out means covariance (can only produce values), in means contravariance (can only consume values). They control how generic types relate to subtyping.

What does the out keyword in Kotlin generics allow?

A Using a subtype where a supertype is expected (covariance)

B Using a supertype where a subtype is expected (contravariance)

C Allowing both input and output of generic type

D Disabling generics

out enables covariance, allowing a subtype to be used where a supertype is expected.

Can a covariant generic type parameter be used as a function parameter inside the class/interface?

A Yes, always

B No, it can only be returned

C Only if marked with <code>in</code>

D Only if the function is private

Covariant type parameters (out) can only be used in output positions, like return types, not as input parameters.

Which of these is a correct example of covariance in Kotlin?

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

B interface Consumer<out T> { fun consume(t: T) }

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

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

Producer with out T can produce values of type T. Consumer with out T is invalid because it consumes T.

What error will Kotlin show if you try to use a covariant type as a function parameter?

A Variance conflict error

B Type mismatch error

C Null pointer exception

D No error

Kotlin shows a variance conflict error because covariant types cannot be used as input parameters.

If List is declared as interface List, what does this mean?

A You can add elements of type T to the list

B The list is mutable

C You can neither add nor read elements

D You can only read elements of type T from the list

Covariant out T means you can safely read elements of type T but not add them.

Explain what 'out variance' (covariance) means in Kotlin generics and why it is useful.

Think about how you can safely use subtypes when returning values.

Describe a situation where using 'out' variance in Kotlin prevents type errors.

Consider a list of animals and dogs.