What is Generic Constraint in Kotlin: Simple Explanation and Example

In Kotlin, a generic constraint limits the types that can be used as arguments for a generic type parameter. It ensures that the generic type meets certain requirements, like inheriting from a specific class or implementing an interface, allowing safer and more predictable code.

How It Works

Imagine you have a box that can hold any item, but you want to make sure it only holds toys. A generic constraint in Kotlin works like a rule that says, "This box can only hold things that are toys or behave like toys." This means when you use a generic type, you tell Kotlin to accept only types that follow certain rules.

Technically, you add a constraint to a generic type parameter using where clauses or by specifying a class or interface after a colon. This tells Kotlin that the type must inherit from a class or implement an interface. This helps the compiler know what functions or properties are safe to use on that generic type.

Without constraints, Kotlin wouldn't know what features the generic type has, so it can't guarantee safe operations. Constraints give you control and safety, like setting a filter on what types can be used.

Example

This example shows a generic function that only accepts types that implement the Comparable interface, so it can compare two values safely.

kotlin

fun <T : Comparable<T>> maxOf(a: T, b: T): T {
    return if (a > b) a else b
}

fun main() {
    println(maxOf(5, 10))
    println(maxOf("apple", "banana"))
    // The following line would cause a compile error because List<Int> is not Comparable
    // println(maxOf(listOf(1, 2), listOf(3, 4)))
}

Output

10
banana

When to Use

Use generic constraints when you want to write flexible code that works with many types but still needs certain features from those types. For example, if you want to compare items, sort them, or call specific methods, you constrain the generic type to ensure those methods exist.

Real-world cases include collections that only accept comparable items, functions that operate on numbers, or classes that require types to implement a specific interface for behavior. This helps catch errors early and makes your code safer and easier to understand.

Key Points

• Generic constraints limit the types allowed for generic parameters.
• They ensure the generic type has certain properties or functions.
• Constraints improve code safety and clarity.
• Use : Type syntax to add constraints in Kotlin.
• Common constraints include classes and interfaces like Comparable.

Key Takeaways

Generic constraints restrict generic types to those that meet specific requirements.

They allow safe use of functions and properties on generic types.

Use constraints to write flexible yet type-safe Kotlin code.

Constraints are added using a colon and a type after the generic parameter.

Common constraints include interfaces like Comparable or base classes.