Out variance (covariance) in Kotlin

Introduction

Out variance helps Kotlin know that a type can only be produced (output) but not consumed (input). This makes code safer and easier to use.

When you want to return a list of animals but don't want to allow adding new animals to it.

When you create a function that produces values of a generic type but never consumes them.

When you want to pass a read-only collection to a function without risking modification.

When you want to make your API more flexible by allowing subtypes to be used safely.

Syntax

Kotlin

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

The out keyword means the generic type T can only be returned (output).

You cannot use T as a parameter type in functions inside this interface.

Examples

This interface produces values of type T. You can get T but not put it in.

Kotlin

interface Source<out T> {
    fun next(): T
}

This function copies elements from a source array that can be any subtype of Any. The out keyword allows safe reading.

Kotlin

fun copy(from: Array<out Any>, to: Array<Any>) {
    for (i in from.indices) {
        to[i] = from[i]
    }
}

Sample Program

This program shows how out allows a Producer<String> to be used where Producer<Any> is expected. It prints the produced string.

Kotlin

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

class StringProducer : Producer<String> {
    override fun produce(): String = "Hello"
}

fun printProduced(producer: Producer<Any>) {
    println(producer.produce())
}

fun main() {
    val stringProducer: Producer<String> = StringProducer()
    printProduced(stringProducer) // Works because of out variance
}

Important Notes

Out variance only allows the generic type to be returned, not accepted as input.

It helps Kotlin keep type safety while allowing flexible use of subtypes.

Try to use out when your generic type is only used for output.

Summary

Out variance means a generic type is only used for output (producing values).

It allows safe use of subtypes, making code more flexible and safe.

Use out keyword in Kotlin interfaces or classes to declare covariance.

Practice

1. What does the out keyword mean in Kotlin generics?

easy

A. The generic type can be used for both input and output.

B. The generic type is used only for input (consuming values).

C. The generic type is used only for output (producing values).

D. The generic type is mutable and can be changed.

Solution

1. Step 1: Understand the meaning of out in Kotlin generics

   The out keyword means the generic type is only used to produce values, not consume them.

2. Step 2: Compare options with this meaning

   The generic type is used only for output (producing values). correctly states that the generic type is used only for output (producing values). Other options describe input or mutability, which are incorrect.

3. Final Answer:

   The generic type is used only for output (producing values). -> Option C

4. Quick Check:

   Out variance = output only [OK]

Hint: Remember: out means output only, no input allowed [OK]

Common Mistakes:

• Confusing out with in variance (input)
• Thinking out allows mutation
• Assuming out means both input and output

2. Which of the following is the correct syntax to declare a covariant generic interface in Kotlin?

easy

A. interface Producer { fun produce(): T }

B. interface Producer { fun produce(): T }

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

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

Solution

1. Step 1: Identify covariance syntax in Kotlin

   Covariance is declared using out before the generic type parameter, like out T.

2. Step 2: Match syntax with options

   interface Producer { fun produce(): T } correctly uses out T and a function that returns T. Other options either use in or lack the out keyword.

3. Final Answer:

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

4. Quick Check:

   Covariant syntax = out T [OK]

Hint: Covariant generics use 'out' before the type parameter [OK]

Common Mistakes:

• Using 'in' instead of 'out' for covariance
• Omitting 'out' keyword
• Confusing input and output functions

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

interface Source {
    fun next(): T
}

class StringSource : Source<String> {
    override fun next() = "Hello"
}

fun printSource(source: Source<Any>) {
    println(source.next())
}

fun main() {
    val stringSource = StringSource()
    printSource(stringSource)
}

medium

A. Hello

B. Compilation error due to type mismatch

C. Runtime error

D. Prints null

Solution

1. Step 1: Understand covariance in the interface

   The interface Source is declared with out T, so Source<String> can be used where Source<Any> is expected.

2. Step 2: Trace the function call and output

   stringSource returns "Hello" from next(). Passing it to printSource works due to covariance, so it prints "Hello".

3. Final Answer:

   Hello -> Option A

4. Quick Check:

   Covariance allows subtype substitution = Hello [OK]

Hint: Covariance lets Source<String> be used as Source<Any> safely [OK]

Common Mistakes:

• Expecting a compilation error due to type mismatch
• Confusing covariance with invariance
• Thinking runtime error occurs

4. Identify the error in this Kotlin code using out variance:

interface Producer {
    fun produce(input: T): T
}

medium

A. No error, code is correct

B. Missing return type in function produce

C. Interface must be declared with in instead of out

D. Cannot use T as a function parameter when declared with out

Solution

1. Step 1: Check usage of generic type T with out variance

   When T is declared with out, it can only be used as a return type, not as a function parameter.

2. Step 2: Analyze the function signature

   The function produce(input: T): T uses T as a parameter, which is not allowed with out T.

3. Final Answer:

   Cannot use T as a function parameter when declared with out -> Option D

4. Quick Check:

   Out variance forbids T as input parameter [OK]

Hint: Out means T only as output, not input parameters [OK]

Common Mistakes:

• Ignoring variance rules for function parameters
• Thinking out allows input parameters
• Confusing in and out variance

5. Given the following Kotlin classes:

open class Animal
class Dog : Animal()

interface Producer {
    fun produce(): T
}

fun feedAnimals(producer: Producer<Animal>) {
    val animal = producer.produce()
    println("Feeding an animal")
}

fun main() {
    val dogProducer: Producer<Dog> = object : Producer<Dog> {
        override fun produce() = Dog()
    }
    feedAnimals(dogProducer)
}

Why does this code compile and run without errors?

hard

A. Because Kotlin ignores variance annotations at runtime

B. Because Producer is covariant with out, allowing Producer<Dog> where Producer<Animal> is expected

C. Because produce() returns a generic type without restrictions

D. Because Dog is a superclass of Animal, so substitution is allowed

Solution

1. Step 1: Understand covariance with out keyword

   The interface Producer is declared with out T, making it covariant. This means Producer<Dog> can be used where Producer<Animal> is expected.

2. Step 2: Analyze class hierarchy and function call

   Dog is a subtype of Animal. The function feedAnimals expects Producer<Animal>, but dogProducer is Producer<Dog>. Covariance allows this substitution safely.

3. Final Answer:

   Because Producer is covariant with out, allowing Producer<Dog> where Producer<Animal> is expected -> Option B

4. Quick Check:

   Covariance allows subtype substitution [OK]

Hint: Covariance lets Producer<Dog> be used as Producer<Animal> [OK]

Common Mistakes:

• Thinking Dog is superclass of Animal
• Ignoring variance and expecting error
• Assuming produce() return type is unrestricted