Generics

A type parameter makes a declaration work for many types without casting. Write class Box<T>(val value: T) and fun <T> identity(x: T): T = x. The name T is a placeholder filled at each use site.

Call a generic function with inference when possible: identity(3) makes T be Int. Spell it when needed: identity<String>("hi"). Construct a generic class the same way: Box(42) or Box<Int>(42).

Constrain a parameter with an upper bound: fun <T : Comparable<T>> maxOf2(a: T, b: T): T = if (a >= b) a else b. Inside the body you may call members of Comparable on T. Without the bound, a >= b would not compile.

Multiple bounds use where: fun <T> sortCopy(list: List<T>): List<T> where T : Comparable<T>, T : Any. Default upper bound is Any?. Prefer one clear bound on the declaration when that is enough.

Misses: writing Java's T extends Comparable instead of T : Comparable<T>, assuming erased T survives as a runtime class without reification (next lessons), or using a raw type like Box without arguments when the API is generic.

class Box<T>(val value: T)

fun <T> identity(x: T): T = x

fun <T : Comparable<T>> maxOf2(a: T, b: T): T =
    if (a >= b) a else b

fun main() {
    val b = Box(42)
    println(identity(b.value))
    println(maxOf2("ada", "grace"))
}