Why Higher-order function declaration in Kotlin? - Purpose & Use Cases

The Big Idea

What if you could write one function that changes its behavior just by plugging in different little pieces of code?

The Scenario

Imagine you want to write several functions that do similar tasks but with slight differences, like sorting a list in different ways or applying different calculations. You write each function separately, repeating similar code again and again.

The Problem

This manual approach is slow and boring. You have to copy and change code many times, which can cause mistakes. If you want to change the common part, you must update every function, risking errors and wasting time.

The Solution

Higher-order functions let you write one flexible function that takes other functions as input. This means you can reuse the main logic and just plug in the different parts, making your code shorter, clearer, and easier to fix.

Before vs After

✗ Before

fun applyDiscount(price: Double): Double {
    return price * 0.9
}
fun applyTax(price: Double): Double {
    return price * 1.1
}

✓ After

fun modifyPrice(price: Double, operation: (Double) -> Double): Double {
    return operation(price)
}

val discount = { p: Double -> p * 0.9 }
val tax = { p: Double -> p * 1.1 }

What It Enables

You can create powerful, reusable functions that adapt to many needs by simply passing different behaviors as arguments.

Real Life Example

Think about a shopping app where prices need different calculations like discounts, taxes, or fees. With higher-order functions, you write one function and pass different calculation rules, saving time and avoiding bugs.

Key Takeaways

Manual repetition of similar functions is slow and error-prone.

Higher-order functions accept other functions as input to reuse logic.

This makes code flexible, shorter, and easier to maintain.