Generics in Kotlin

Generics are a powerful feature in many programming languages, including Kotlin. They allow you to write code that is flexible and reusable by defining algorithms in terms of types to-be-specified-later. In this article, we'll take a deep dive into the concept of Generics in Kotlin, and how you can use them to make your Kotlin code more efficient and robust.

Understanding Generics

Generics are a way of making classes, interfaces, or methods work on various types of data while providing type safety. They allow you to create a single class or method that can work with different data types, while still benefiting from static type checking.

Let's look at a simple example of a generic class:

class Box<T>(t: T) {
    var value = t
}

In the example above, T is a type parameter that represents any type. This means that Box is a generic class that can hold a value of any type. You can create a new instance of Box for different types:

val box1: Box<Int> = Box<Int>(1)
val box2: Box<String> = Box<String>("Hello")

Variance in Generics

Generics in Kotlin also support variance, which is the relationship between different types and their subclasses. There are two main types of variance in Kotlin - Covariance and Contravariance.

Covariance

Covariance means that if Type B is a subtype of Type A, then GenericType<B> can be treated as a subtype of GenericType<A>. Kotlin supports covariance using the out keyword.

Here's an example of a covariant class in Kotlin:

class Box<out T>(private val t: T) {
    fun get(): T = t
}

In this example, Box<T> is covariant in T because T only appears as an output (return type of a method), not as an input.

Contravariance

Contravariance is the opposite of covariance. It means that if Type B is a subtype of Type A, then GenericType<A> can be treated as a subtype of GenericType<B>. Kotlin supports contravariance using the in keyword.

Here's an example of a contravariant class in Kotlin:

class Box<in T> {
    fun put(t: T) { /*...*/ }
}

In this example, Box<T> is contravariant in T because T only appears as an input (parameter of a method), not as an output.

Type Projections

Kotlin also supports type projections, which are a way of using generic types that might not have the same variance. There are two types of projections: in-projections and out-projections.

An out-projection (out T) is a safe producer of T (it produces Ts), but it's an unsafe consumer.

An in-projection (in T) is a safe consumer of T (it consumes Ts), but it's an unsafe producer.

Conclusion

Generics are a powerful tool that can help you to write flexible, reusable, and type-safe code in Kotlin. Understanding how to use generics, along with variance and type projections, can significantly improve your Kotlin programming skills. Remember to always consider the type safety and reusability of your code when designing your classes and methods.