Why operators are functions in Kotlin - Performance Analysis

Time Complexity: Why operators are functions in Kotlin

O(n)

Understanding Time Complexity

We want to understand how using operators as functions affects the time it takes for Kotlin code to run.

How does calling an operator as a function change the work done by the program?

Scenario Under Consideration

Analyze the time complexity of the following Kotlin code using operator functions.

class Point(val x: Int, val y: Int) {
    operator fun plus(other: Point): Point {
        return Point(x + other.x, y + other.y)
    }
}

fun sumPoints(points: List): Point {
    var result = Point(0, 0)
    for (p in points) {
        result += p
    }
    return result
}
    

This code defines a Point class where the plus operator is a function. It sums a list of points using this operator function.

Identify Repeating Operations

Look for loops or repeated calls that do the main work.

• Primary operation: The loop in sumPoints calls the plus operator function once per point.
• How many times: The loop runs once for each point in the list, so n times where n is the list size.

How Execution Grows With Input

Each point in the list causes one addition operation using the operator function.

Input Size (n)	Approx. Operations
10	10 additions
100	100 additions
1000	1000 additions

Pattern observation: The number of operations grows directly with the number of points.

Final Time Complexity

Time Complexity: O(n)

This means the time to sum points grows in a straight line as the list gets bigger.

Common Mistake

[X] Wrong: "Using operator functions makes the code slower because functions are always slower than operators."

[OK] Correct: In Kotlin, operators are just special functions. Calling them is no different in speed than calling a normal function, so the time grows the same way.

Interview Connect

Understanding that operators are functions helps you explain how Kotlin keeps code clean without losing speed. This shows you know how language design affects performance.

Self-Check

What if the plus operator function did more work inside, like logging each addition? How would that affect the time complexity?