Reified type parameters with inline in Kotlin - Time & Space Complexity

Time Complexity: Reified type parameters with inline

O(n)

Understanding Time Complexity

We want to understand how the time it takes to run code with reified type parameters changes as input grows.

Specifically, how does using inline functions with reified types affect performance?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

inline fun <reified T> findFirstOfType(list: List<Any>): T? {
    for (item in list) {
        if (item is T) {
            return item
        }
    }
    return null
}

This function looks through a list to find the first item of a specific type T using a reified type parameter.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through the list items one by one.
• How many times: Up to the size of the list, until the first matching item is found or the list ends.

How Execution Grows With Input

As the list gets bigger, the function may check more items before finding a match or finishing.

Input Size (n)	Approx. Operations
10	Up to 10 checks
100	Up to 100 checks
1000	Up to 1000 checks

Pattern observation: The number of checks grows roughly in direct proportion to the list size.

Final Time Complexity

Time Complexity: O(n)

This means the time to find the first item grows linearly with the list size.

Common Mistake

[X] Wrong: "Using reified types makes the search faster because the type is known at runtime."

[OK] Correct: The reified type allows type checks without reflection, but the function still checks items one by one, so the time depends on list size.

Interview Connect

Understanding how inline and reified types affect performance helps you explain your code choices clearly and shows you know how code runs as data grows.

Self-Check

"What if we changed the list to a set? How would the time complexity change?"