Lambdas and higher-order functions

Functions as values

In Kotlin you can store a function in a variable, pass it to another function, and return it from a function, just like a number or a string. This lets you pass behaviour around: "sort by price", "keep only paid orders", "run this when the button is clicked".

Lambda syntax

val add = { a: Int, b: Int -> a + b }
println(add(3, 4))           // 7

val shout: (String) -> String = { text -> text.uppercase() + "!" }
println(shout("jai hind"))   // JAI HIND!

The type (String) -> String reads "a function that takes a String and returns a String". () -> Unit is a function that takes nothing and returns nothing, like a click handler.

Why does this matter for Android? Almost every Android API that reacts to something takes a function: what to do when a button is clicked, when a network call finishes, when a list item is swiped. Instead of writing a whole class for each reaction (the old Java way), you pass a short lambda right where it is used, so the reaction sits next to the code it belongs to.

it: the implicit parameter

val double: (Int) -> Int = { it * 2 }
println(double(21))          // 42

Higher-order functions

A higher-order function is a function that takes another function as a parameter or returns one. The collection functions you will use daily (filter, map, sortedBy, forEach) are all higher-order functions.

fun applyDiscount(price: Int, rule: (Int) -> Int): Int = rule(price)

fun main() {
    val festive = { p: Int -> p - p / 10 }        // 10% off
    println(applyDiscount(500, festive))          // 450
    println(applyDiscount(500) { it - 50 })       // 450: trailing lambda
}

Trailing lambda syntax

If the last parameter of a function is a function, you can write the lambda after the closing parenthesis. If it is the only argument, you can drop the parentheses completely. This is used everywhere in Kotlin and Android:

val prices = listOf(120, 45, 300)
val big = prices.filter { it > 100 }        // [120, 300]
repeat(2) { println("Hi") }

// Jetpack Compose (module 6) uses the same idea:
// Button(onClick = { count++ }) { Text("Add") }
// Column { Text("Name"); Text("City") }

Function references

fun isEven(n: Int) = n % 2 == 0

val evens = listOf(1, 2, 3, 4).filter(::isEven)   // [2, 4]

Lambdas capture variables

var clicks = 0
val onClick = { clicks++ }
onClick()
onClick()
println(clicks)    // 2

Common mistakes

• Using return inside a lambda passed to forEach and expecting it to skip one item: a plain return returns from the enclosing function. Use return@forEach or filter first.
• Forgetting that the last expression in a lambda is its result. Do not write return there.
• Overly long lambdas. If it is more than a few lines, make it a named function and pass ::name.
• Confusing it in nested lambdas. Give parameters names when lambdas are nested.