Kotlin Lambdas and Higher-Order Functions

val double: (Int) -> Int = { n -> n * 2 }
val add = { a: Int, b: Int -> a + b }
println(double(5))      // 10
println(add(2, 3))      // 5

• A lambda is written in curly braces: parameters, then ->, then the body.
• The last expression in the body is the result; there's no return.
• A function type describes inputs and output: (Int) -> Int takes an Int and returns one; (String, Int) -> Boolean takes two values; () -> Unit takes nothing and returns nothing.
• If the type is known, parameter types can be left out: val double: (Int) -> Int = { n -> n * 2 }.

When a lambda has exactly one parameter, you can skip naming it and use it:

val isEven: (Int) -> Boolean = { it % 2 == 0 }

If a function's last parameter is a function, the lambda can go outside the brackets. If it's the only argument, the brackets can disappear entirely:

numbers.filter({ it > 0 })     // allowed, but unusual
numbers.filter() { it > 0 }    // trailing lambda
numbers.filter { it > 0 }      // the usual style

This is why so much Kotlin code reads like repeat(3) { ... } or list.forEach { ... }.

Declare a parameter with a function type, then call it like a normal function:

fun applyTwice(x: Int, f: (Int) -> Int): Int = f(f(x))

applyTwice(3) { it + 10 }      // 23

A function can also return a function, which is useful for building customised behaviour:

fun multiplier(factor: Int): (Int) -> Int = { it * factor }
val triple = multiplier(3)
triple(7)                       // 21

The returned lambda remembers factor even after multiplier has finished. That's called a closure.

If an existing function already does the job, pass a reference to it with :: instead of wrapping it in a lambda:

fun isLong(word: String) = word.length > 5
words.filter(::isLong)
words.map(String::uppercase)

Inside a lambda, a plain return would return from the enclosing function, which is rarely what you want. To skip to the next item in forEach, use a labelled return: return@forEach. Usually the clearer fix is to use filter first, so there's nothing to skip.

A lambda doesn't only read the variables around it; it can change them too. Each call to makeCounter below creates a fresh count, and the returned lambda keeps hold of it:

fun makeCounter(): () -> Int {
    var count = 0
    return { ++count }
}

val next = makeCounter()
println(next())    // 1
println(next())    // 2
val other = makeCounter()
println(other())   // 1, a separate count

This is how lambdas can carry private state without a class. Use it sparingly, though: when several lambdas change the same variable, it gets hard to follow who changed what.

When a lambda receives a pair or a map entry, you can unpack it in brackets, and replace any part you don't need with _:

prices.forEach { (item, price) -> println("$item: $price") }
prices.forEach { (_, price) -> println(price) }

Function types can be nullable, which is a neat way to make a callback optional. Wrap the type in brackets before the ?, and call it with ?.invoke:

fun download(url: String, onDone: ((String) -> Unit)? = null) {
    onDone?.invoke("done: $url")
}

download("a.txt")                      // no callback, nothing printed
download("b.txt") { println(it) }      // prints done: b.txt

Because lambdas are values, you can also store them in collections. A map from symbols to operations makes a tiny calculator with no when at all:

val ops: Map<String, (Int, Int) -> Int> = mapOf(
    "+" to { a, b -> a + b },
    "*" to { a, b -> a * b },
)
println(ops["*"]?.invoke(6, 7))   // 42

The lookup returns a nullable function, since the key might be missing, so the safe call ?.invoke is needed here as well.