Why extensions add without modifying in Kotlin - Performance Analysis

Time Complexity: Why extensions add without modifying

O(n)

Understanding Time Complexity

When we add new features using extensions in Kotlin, we want to know how this affects the program's speed.

We ask: How does adding extensions change the work the program does as input grows?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fun List<Int>.sumOfSquares(): Int {
    var sum = 0
    for (num in this) {
        sum += num * num
    }
    return sum
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    println(numbers.sumOfSquares())
}
    

This code adds a new function to List<Int> that calculates the sum of squares of its elements without changing the original List class.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through each element of the list to calculate its square and add it.
• How many times: Once for each element in the list (n times).

How Execution Grows With Input

As the list gets bigger, the function does more work by repeating the square and add steps for each new item.

Input Size (n)	Approx. Operations
10	About 10 squares and adds
100	About 100 squares and adds
1000	About 1000 squares and adds

Pattern observation: The work grows directly with the number of items; double the items, double the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to run the extension grows in a straight line with the size of the list.

Common Mistake

[X] Wrong: "Adding an extension function changes the original class and makes it slower overall."

[OK] Correct: Extensions add new functions without changing the original class code, so they only add the cost of their own operations, not extra hidden work.

Interview Connect

Understanding how extensions work helps you explain how new features can be added safely without slowing down existing code, a useful skill in many coding tasks.

Self-Check

What if the extension function called another function inside a nested loop? How would the time complexity change?

Practice

1. What is the main reason Kotlin extensions add functionality without modifying the original class?

easy

A. They create new functions outside the class without changing its code

B. They rewrite the original class bytecode

C. They require inheritance from the original class

D. They replace the original class methods at runtime

Solution

1. Step 1: Understand how extensions work

   Kotlin extensions define new functions outside the original class without altering its source code.

2. Step 2: Compare with other options

   Options A, B, and D involve modifying or replacing the original class, which extensions do not do.

3. Final Answer:

   They create new functions outside the class without changing its code -> Option A

4. Quick Check:

   Extensions add functions externally = C [OK]

Hint: Extensions add functions externally, no class code change [OK]

Common Mistakes:

• Thinking extensions modify original class code
• Confusing extensions with inheritance
• Believing extensions replace methods at runtime

2. Which of the following is the correct syntax to define an extension function greet for the String class in Kotlin?

easy

A. fun greet() = String { println("Hello") }

B. fun greet(String) { println("Hello") }

C. fun greet() String { println("Hello") }

D. fun String.greet() { println("Hello") }

Solution

1. Step 1: Recall extension function syntax

   Extension functions are declared as fun ClassName.functionName(), so for String: fun String.greet().

2. Step 2: Validate options

   fun String.greet() { println("Hello") } matches correct syntax. Others have wrong parameter placement or return type.

3. Final Answer:

   fun String.greet() { println("Hello") } -> Option D

4. Quick Check:

   Extension syntax = fun ClassName.functionName() [OK]

Hint: Extension syntax: fun ClassName.functionName() [OK]

Common Mistakes:

• Placing class name as parameter instead of receiver
• Incorrect return type syntax
• Using function without receiver type

3. What will be the output of this Kotlin code?

fun String.shout() = this.uppercase() + "!"

fun main() {
    val word = "hello"
    println(word.shout())
}

medium

A. hello!

B. HELLO!

C. Hello!

D. Error: No such function

Solution

1. Step 1: Understand the extension function

   The extension shout() converts the string to uppercase and adds an exclamation mark.

2. Step 2: Apply the function to "hello"

   "hello" becomes "HELLO" plus "!" resulting in "HELLO!".

3. Final Answer:

   HELLO! -> Option B

4. Quick Check:

   Uppercase + ! = HELLO! [OK]

Hint: Extension adds uppercase and ! to string [OK]

Common Mistakes:

• Assuming original string unchanged
• Confusing uppercase with capitalized
• Expecting runtime error for extension

4. Identify the error in this Kotlin extension function code:

fun Int.addFive() = this + 5

fun main() {
    val number = 10
    println(number.addfive())
}

medium

A. Missing return type in extension function

B. Extension function cannot be defined on Int

C. Function call uses wrong case: addfive() instead of addFive()

D. Cannot call extension function on val variable

Solution

1. Step 1: Check extension function definition

   The extension addFive() is correctly defined on Int with proper syntax.

2. Step 2: Check function call in main()

   The call uses addfive() with lowercase 'f', which does not match the defined function name.

3. Final Answer:

   Function call uses wrong case: addfive() instead of addFive() -> Option C

4. Quick Check:

   Function names are case-sensitive = A [OK]

Hint: Function names are case-sensitive in Kotlin [OK]

Common Mistakes:

• Ignoring case sensitivity in function calls
• Thinking extension can't be on Int
• Assuming val variables can't use extensions

5. You want to add a function isEven() to the Int class that returns true if the number is even, without modifying the original Int class. Which Kotlin code correctly achieves this and why does it not change the original class?

hard

A. fun Int.isEven() = this % 2 == 0 // Adds function externally without changing Int class

B. class Int { fun isEven() = this % 2 == 0 } // Rewrites Int class

C. fun isEven(n: Int) = n % 2 == 0 // Defines a separate function, not extension

D. Int.isEven = { this % 2 == 0 } // Attempts to assign function to Int class

Solution

1. Step 1: Identify correct extension syntax

   fun Int.isEven() = this % 2 == 0 defines an extension function on Int using fun Int.isEven(), which is the correct way.

2. Step 2: Understand why original class is unchanged

   Extensions add functions externally without modifying or rewriting the original Int class bytecode.

3. Final Answer:

   fun Int.isEven() = this % 2 == 0 // Adds function externally without changing Int class -> Option A

4. Quick Check:

   Extension adds function externally = D [OK]

Hint: Extensions add functions externally, no class rewrite [OK]

Common Mistakes:

• Trying to redefine Int class directly
• Confusing extension with normal function
• Attempting to assign function to class property