Understanding in and out Keywords in Kotlin

Introduction

Dive into Kotlin's type projections with 'in' and 'out' keywords. 'in' handles input flexibility, allowing less specific subtypes, while 'out' manages return types with more specificity. Understand how covariance and contravariance simplify subtype relationships and supertype treatment. Real-world examples illustrate these concepts in action, ensuring practical insights. Mastering 'in' and 'out' empowers developers to write adaptable and resilient Kotlin code.

Type Projections with in and out

Using in Keyword

The in keyword is used for contravariant type projections, allowing a type to be treated as a less specific subtype. This is particularly useful when dealing with input parameters.

interface Box<in T> {
    fun put(item: T)
}

fun fillBox(box: Box<in Fruit>, fruit: Fruit) {
    box.put(fruit)
}        

In this example, a Box with contravariant type T is defined. The fillBox function accepts a Box of any fruit subtype, allowing it to put fruits into the box.

Using out Keyword

Conversely, the out keyword is used for covariant type projections, enabling a type to be treated as a more specific subtype. This is beneficial when dealing with return types.

interface Basket<out T> {

    fun take(): T

}

fun emptyBasket(basket: Basket<out Vegetable>): Vegetable {

    return basket.take()

}        

Here, a Basket with covariant type T is created. The emptyBasket function can take a basket of any vegetable subtype and returns a vegetable.

Covariance

Covariance ensures that a generic type preserves the subtype relationship. In our example, Basket<out T> allows the returned type (T) to be a subtype of the defined type. This is safe as we can always treat a basket of vegetables as a basket of items.

Contravariance

Contravariance allows a generic type to be treated as a supertype. In our example, Box<in T> permits putting items of a more generic type into the box. This is safe because it ensures that any box that can contain fruits can also contain apples, for instance.

Use Cases

Covariance in Action

open class Animal

class Mammal : Animal()

fun getMammalBasket(): Basket<Mammal> {

    // Implementation details

}        

Here, Basket<out T> enables us to return a more specific subtype (Mammal) while still adhering to the covariance principle.

Contravariance in Action

open class Juice

class AppleJuice : Juice()

fun fillFruitBox(box: Box<in AppleJuice>, juice: AppleJuice) {

    box.put(juice)

}        

In this case, Box<in T> allows us to put a more specific type (AppleJuice) into a box that can hold a broader range of items.

Conclusion

Understanding in and out keywords in Kotlin is pivotal for leveraging covariance and contravariance to ensure type safety in generic programming. These features empower developers to create flexible and robust code while maintaining a high level of abstraction.

I hope that this article has been helpful to you. ??