How do higher-order functions and inline functions work?
Assesses fundamental understanding of Kotlin conventions, runtime behavior, and memory/performance considerations.
Hiring managers look for precision, avoidance of ambiguous jargon, and ability to explain trade-offs under real production conditions.
A higher-order function takes a function as a parameter or returns one. Functions are first-class values with types like (Int) -> Int.
fun <T> List<T>.myFilter(predicate: (T) -> Boolean): List<T> {
val out = mutableListOf<T>()
for (item in this) if (predicate(item)) out.add(item)
return out
}
val evens = (1..10).myFilter { it % 2 == 0 }
Lambdas passed to such functions are objects, so each call allocates and adds an indirect call. Marking the function inline substitutes its body at the call site, eliminating the lambda object and enabling non-local returns, where a return inside the lambda returns from the enclosing function.
inline fun measure(block: () -> Unit) {
val start = System.nanoTime()
block()
println(System.nanoTime() - start)
}
Standard functions like let, run and apply are inline. Avoid inlining large functions or functions that store their lambda parameters.
Candidate Response Strategy & Interview Tips
- Start with a concise one-sentence summary: Deliver a direct, confident answer first before expanding into nuances.
- Demonstrate real-world trade-offs: Discuss where this approach excels and when you would avoid it in production systems.
- Discuss complexity & edge cases: Proactively explain time/space complexity or boundary conditions (null values, scale limits).
- Prepare for interviewer follow-ups: Technical hiring panels frequently probe deeper into concurrency, backward compatibility, or alternative libraries.