Generic constraints with where clause in Kotlin - Time & Space Complexity

Time Complexity: Generic constraints with where clause

O(n)

Understanding Time Complexity

We want to understand how the time it takes to run a generic function with constraints grows as the input size increases.

Specifically, how does the use of a where clause affect the work done inside the function?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fun  printAll(items: List) where T : CharSequence, T : Comparable {
    for (item in items) {
        println(item)
    }
}
    

This function prints all items in a list where each item must be a character sequence and comparable.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through each item in the list.
• How many times: Once for each item in the list.

How Execution Grows With Input

As the list gets bigger, the function prints more items, so the work grows directly with the number of items.

Input Size (n)	Approx. Operations
10	10 print operations
100	100 print operations
1000	1000 print operations

Pattern observation: The work grows evenly as the list size grows.

Final Time Complexity

Time Complexity: O(n)

This means the time to run the function grows in a straight line with the number of items.

Common Mistake

[X] Wrong: "Adding generic constraints with where makes the function slower for each item."

[OK] Correct: The constraints only check types at compile time and do not add extra work when running the loop.

Interview Connect

Understanding how generic constraints affect performance helps you write clear and efficient code that scales well with input size.

Self-Check

"What if the function also sorted the list before printing? How would the time complexity change?"