Extension function syntax in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a simple extension function call

What is the output of this Kotlin code using an extension function?

Kotlin

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

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

A hello!

B HELLO!

C Hello!

D HELLO

💡 Hint

Remember that the extension function converts the string to uppercase and adds an exclamation mark.

The extension function shout() converts the string to uppercase and appends an exclamation mark, so "hello" becomes "HELLO!".

🧠 Conceptual

intermediate

Understanding receiver type in extension functions

In Kotlin, what does the receiver type in an extension function represent?

A The type of the object the extension function is called on

B The type of the variable inside the extension function

C The type of the parameter passed to the extension function

D The return type of the extension function

💡 Hint

Think about what object you are extending when you write an extension function.

The receiver type is the type of the object that the extension function is called on, allowing you to add new functions to that type.

🔧 Debug

advanced

Identify the error in this extension function

What error will this Kotlin code produce?

Kotlin

fun Int.add(x: Int): Int {
    return this + x
}

fun main() {
    val result = 5.add()
    println(result)
}

A Error: No value passed for parameter 'x'

B Error: Extension function cannot have parameters

C Error: 'this' cannot be used in extension functions

D No error, output is 5

💡 Hint

Check how the extension function is called and what parameters it expects.

The extension function add requires one parameter 'x', but the call 5.add() provides none, causing a compilation error.

📝 Syntax

advanced

Correct syntax for extension function with nullable receiver

Which option shows the correct syntax for an extension function on a nullable String receiver that returns its length or zero if null?

A fun String?.lengthOrZero() = length ?: 0

B fun String.lengthOrZero() = this?.length ?: 0

C fun String?.lengthOrZero() = this?.length ?: 0

D fun String?.lengthOrZero() = this.length ?: 0

💡 Hint

Remember to use the safe call operator when the receiver can be null.

Option C correctly declares the receiver as nullable String? and uses safe call 'this?.length' to avoid null pointer exceptions.

🚀 Application

expert

Extension function to filter and transform a list

Given this extension function on List, what is the output of the code below?

Kotlin

fun List<Int>.filterAndDouble(predicate: (Int) -> Boolean): List<Int> {
    val result = mutableListOf<Int>()
    for (item in this) {
        if (predicate(item)) {
            result.add(item * 2)
        }
    }
    return result
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    val filtered = numbers.filterAndDouble { it % 2 == 1 }
    println(filtered)
}

A [2, 4, 6, 8, 10]

B [1, 3, 5]

C [1, 2, 3, 4, 5]

D [2, 6, 10]

💡 Hint

The predicate filters odd numbers, then doubles them before adding to the result list.

The function filters odd numbers (1,3,5) and doubles them (2,6,10), so the output is [2, 6, 10].

Practice

1. What is the correct way to declare an extension function greet for the String type in Kotlin?

easy

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

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

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

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

Solution

1. Step 1: Understand extension function syntax

   Extension functions use the syntax fun ReceiverType.functionName(). Here, String is the receiver type.

2. Step 2: Match the syntax with options

   fun String.greet() { println("Hello, $this") } correctly uses fun String.greet(). Other options do not follow this syntax.

3. Final Answer:

   fun String.greet() { println("Hello, $this") } -> Option C

4. Quick Check:

   Extension function syntax = fun ReceiverType.functionName() [OK]

Hint: Look for 'fun ReceiverType.functionName()' pattern [OK]

Common Mistakes:

• Using 'extension' keyword which doesn't exist
• Placing receiver type as function parameter
• Missing receiver type before function name

2. Which of the following is the correct syntax to declare an extension function square for Int that returns the square of the number?

easy

A. fun Int.square(): Int = this * this

B. fun Int.square() { this * this }

C. fun Int.square() = Int * Int

D. fun square(Int): Int = this * this

Solution

1. Step 1: Check extension function declaration with return type

   The syntax is fun ReceiverType.functionName(): ReturnType = expression. fun Int.square(): Int = this * this matches this.

2. Step 2: Verify usage of 'this' and return

   fun Int.square(): Int = this * this correctly uses this * this and returns Int. fun Int.square() { this * this } uses braces (block body) but misses return statement, thus returns Unit. fun Int.square() = Int * Int uses invalid Int * Int.

3. Final Answer:

   fun Int.square(): Int = this * this -> Option A

4. Quick Check:

   Extension function with return type = fun ReceiverType.functionName(): Type [OK]

Hint: Remember extension functions use receiver before dot and return type after parentheses [OK]

Common Mistakes:

• Placing receiver type as function parameter
• Using braces without return in expression body
• Incorrect return type placement

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

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

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

medium

A. hello!

B. HELLO!

C. Hello!

D. Compilation error

Solution

1. Step 1: Understand the extension function behavior

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

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

   Calling word.shout() returns "HELLO!" which is printed.

3. Final Answer:

   HELLO! -> Option B

4. Quick Check:

   Extension function output = uppercase + "!" [OK]

Hint: Check what extension function returns and apply to variable [OK]

Common Mistakes:

• Assuming original string changes
• Ignoring uppercase conversion
• Thinking extension functions modify original object

4. Identify the error in the following Kotlin extension function declaration:

fun Int.double {
    return this * 2
}

medium

A. Missing parentheses after function name

B. Cannot use 'this' in extension functions

C. Return statement not allowed in extension functions

D. Extension functions cannot be declared for Int

Solution

1. Step 1: Check function declaration syntax

   Functions must have parentheses after the name, even if no parameters are present. Here, double misses parentheses.

2. Step 2: Verify other parts

   Using this is valid in extension functions. Return statements are allowed. Extension functions can be declared for Int.

3. Final Answer:

   Missing parentheses after function name -> Option A

4. Quick Check:

   Function declaration requires parentheses () [OK]

Hint: Always add () after function name even if no parameters [OK]

Common Mistakes:

• Omitting parentheses in function declaration
• Misunderstanding 'this' usage
• Thinking return is disallowed

5. You want to add an extension function isEven() to Int? (nullable Int) that returns true if the number is even, and false if it's odd or null. Which is the correct way to declare this extension function?

hard

A. fun Int.isEven(): Boolean = this % 2 == 0 || this == null

B. fun Int.isEven(): Boolean = this % 2 == 0

C. fun Int?.isEven(): Boolean { if (this == null) return false else return this % 2 != 0 }

D. fun Int?.isEven(): Boolean = this != null && this % 2 == 0

Solution

1. Step 1: Understand nullable receiver type

   To extend nullable Int, use Int? as receiver type. fun Int?.isEven(): Boolean = this != null && this % 2 == 0 does this correctly.

2. Step 2: Check logic for null and even check

   fun Int?.isEven(): Boolean = this != null && this % 2 == 0 uses concise expression: returns false if null, true if even. fun Int?.isEven(): Boolean { if (this == null) return false else return this % 2 != 0 } is verbose but has incorrect logic (returns true for odd). fun Int.isEven(): Boolean = this % 2 == 0 || this == null incorrectly uses non-nullable receiver and wrong logic. fun Int.isEven(): Boolean = this % 2 == 0 ignores null.

3. Final Answer:

   fun Int?.isEven(): Boolean = this != null && this % 2 == 0 -> Option D

4. Quick Check:

   Nullable receiver uses '?' and checks null explicitly [OK]

Hint: Use '?' after type for nullable receiver and check null inside [OK]

Common Mistakes:

• Not using nullable receiver type for Int?
• Ignoring null checks inside function
• Using non-nullable receiver for nullable types