Why Generic constraints with where clause in Kotlin? - Purpose & Use Cases

The Big Idea

What if you could write one function that safely handles many types without messy checks?

The Scenario

Imagine you have a collection of different types of data, like numbers, strings, and custom objects, and you want to write a function that works only with certain types that meet specific rules.

Without a way to specify these rules, you might try to write separate functions for each type or check types manually inside the function.

The Problem

Manually checking types or writing many versions of the same function is slow and error-prone.

It makes your code messy and hard to maintain because you repeat yourself and risk missing cases or making mistakes.

The Solution

Generic constraints with the where clause let you tell the compiler exactly what rules the types must follow.

This means you can write one clear, safe function that works only with types that meet your conditions, avoiding errors and extra code.

Before vs After

✗ Before

fun process(item: Any) {
  if (item is Number) {
    // do something
  } else if (item is String) {
    // do something else
  }
}

✓ After

fun <T> process(item: T) where T : Number, T : Comparable<T> {
  // safe to use Number and Comparable methods
}

What It Enables

You can create flexible, reusable functions that work only with types meeting your exact needs, making your code safer and cleaner.

Real Life Example

Suppose you build a database query builder that only accepts types that can be compared and converted to strings. Using generic constraints with where, you ensure only valid types are used, preventing runtime errors.

Key Takeaways

Manual type checks lead to messy, error-prone code.

where clauses let you specify exact type rules for generics.

This makes your functions safer, clearer, and easier to maintain.