Generics

Why Generics?

Without generics, you write separate implementations for every type or use Any (which loses type safety). Generics let you write a single class or function that works with any type while preserving compile-time type checking.

// Without generics: type-unsafe
class Box {
    var value: Any? = null
}
val box = Box()
box.value = "hello"
val text: String = box.value as String  // Unsafe cast

// With generics: type-safe
class Box<T>(var value: T)
val box = Box("hello")
val text: String = box.value  // No cast needed

Generic Classes

A generic class accepts a type parameter (conventionally T, E, K, V):

class Pair<A, B>(val first: A, val second: B)

val pair = Pair(1, "one")  // Pair<Int, String>
println(pair.first)         // 1 (Int)
println(pair.second)        // one (String)

Type parameters can be constrained. If a function needs to call methods on the type, add an upper bound:

class StringBox<T : String>(val value: T) {
    fun length() = value.length
}

val box = StringBox("Hello")
println(box.length())  // 5
// val intBox = StringBox(42)  // Compile error: Int is not a String

The : String constraint means T must be String or a subtype of String.

Generic Functions

Generic functions declare type parameters in angle brackets before the function name:

fun <T> singletonList(item: T): List<T> {
    return listOf(item)
}

val list = singletonList(42)  // List<Int>
val names = singletonList("Kotlin")  // List<String>

Type inference usually determines T automatically. When it cannot, specify explicitly:

fun <T> emptyList(): List<T> = emptyList()
val empty = emptyList<String>()  // Explicit type needed

Generic Constraints

Use where to require multiple bounds:

fun <T> process(item: T) where T : Comparable<T>, T : Serializable {
    // T must implement both Comparable and Serializable
}

// Or with a single bound:
fun <T : Comparable<T>> sort(list: List<T>): List<T> {
    return list.sorted()
}

The Variance Problem

Consider a simple holder class:

class Box<T>(val value: T)

If Dog is a subtype of Animal, is Box a subtype of Box? In Kotlin, the answer depends on variance. By default, generics are invariant: Box is NOT a subtype of Box, even though Dog is a subtype of Animal. This prevents you from putting a Cat into a Box.

Out (Covariance)

Mark a type parameter out if the class only produces (reads) values of type T. This makes the generic covariant: Box becomes a subtype of Box:

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

fun demo(strs: Source<String>) {
    val objects: Source<Any> = strs  // Allowed because of out
}

With out, T can only appear in output positions (return types). You cannot pass T as a function parameter.

In (Contravariance)

Mark a type parameter in if the class only consumes (writes) values of type T. This makes the generic contravariant: Box becomes a subtype of Box:

interface Comparable<in T> {
    fun compareTo(other: T): Int
}

fun demo(x: Comparable<Animal>) {
    x.compareTo(Dog())  // Allowed because of in
}

With in, T can only appear in input positions (function parameters). You cannot use T as a return type.

Star Projection

Use * when you do not care about the type parameter, similar to ? in Java wildcards:

fun printAll(list: List<*>) {
    for (item in list) {
        println(item)
    }
}

printAll(listOf(1, "hello", 3.14))

Type Erasure

At runtime, generic type information is erased. You cannot check T is String at runtime. Use reified type parameters with inline functions to preserve type information:

inline fun <reified T> isType(value: Any): Boolean {
    return value is T
}

println(isType<String>("hello"))  // true
println(isType<Int>("hello"))     // false

The reified keyword keeps the type information available at runtime by inlining the function body.