Extension Functions and Higher-Order Functions

# CHAPTER 18

Extension Functions and Higher-Order Functions #

1. Chapter Introduction #

2. Learning Objectives #

• Write and use Extension Functions.

• Understand the concept of "Receiver types".

• Understand what a Higher-Order Function is.

• Pass a function as an argument to another function.

• Define Function Types (e.g., (Int, Int) -> Int).

3. Extension Functions #

// We add a new function to the String class!
// 'String' is the receiver type. 'this' refers to the actual string.
fun String.removeFirstAndLast(): String {
    return this.substring(1, this.length - 1)
}

fun main() {
    val myWord = "Kotlin"
    
    // It looks like a native Kotlin method!
    println(myWord.removeFirstAndLast()) // Output: otli
}

*Note: Extension functions do not actually modify the original class source code. The compiler resolves them statically. They are syntactic sugar that makes code highly readable.*

4. Higher-Order Functions #

1. 1. Takes another function as a parameter.

1. 2. Returns a function.

#### Defining a Function Type If we want to pass a function as a parameter, we must declare its type.

• () -> Unit : A function taking no arguments and returning nothing.

• (Int, Int) -> Int : A function taking two Ints and returning an Int.

#### Passing a Function as a Parameter Let's build a calculator that accepts the math operation as a function!

// The 3rd parameter 'operation' is a FUNCTION!
fun calculate(x: Int, y: Int, operation: (Int, Int) -> Int): Int {
    return operation(x, y) // We execute the passed function here
}

// A standard function that matches the (Int, Int) -> Int signature
fun sum(a: Int, b: Int): Int {
    return a + b
}

fun main() {
    // We pass the 'sum' function using the :: operator
    val result = calculate(10, 5, ::sum)
    println("Result: $result") // 15
}

5. Passing Anonymous Functions (Lambdas Preview) #

fun main() {
    // We define the logic { a, b -> a * b } right inside the call!
    val result = calculate(10, 5, { a, b -> a * b })
    println("Multiplied: $result") // 50
}

6. Built-in Higher-Order Functions #

7. Common Mistakes #

• Abusing Extension Functions: Because they are so easy to write, beginners often write Extension Functions for everything instead of creating proper Classes. If an extension relies on state, it should probably be a method inside a Class.

• Forgetting ::: If you want to pass an existing function into a higher-order function, you must use the method reference operator :: (e.g., ::sum). Writing calculate(5, 5, sum) will cause an error because it thinks you are trying to *execute* sum rather than pass it.

8. Best Practices #

• Extend 3rd-Party Libraries: Extension functions shine when you are using external libraries (like Android UI elements or JSON parsers) and want to create shortcut methods for repetitive tasks specific to your project.

9. Exercises #

1. 1. Write an extension function for Int called .isEven(). It should return a Boolean.

1. 2. Inside .isEven(), check if this % 2 == 0.

1. 3. In main(), print 10.isEven() and 7.isEven().

10. MCQs with Answers #

Q10. Can you define an extension function on an external library class you did not write? a) Yes b) No Answer: a) Yes.

11. Interview Questions #

• Q: What is an Extension Function? Does it violate Object-Oriented Encapsulation? (Answer: No, because extension functions cannot access private members of the receiver class. They only have access to the public API).

• Q: Explain what a Higher-Order Function is and provide an example of a common one found in the Kotlin standard library (e.g., .map() or .filter()).

12. Summary #

13. Next Chapter Recommendation #