Lambdas and higher-order functions

You have been doing this for two lessons

Look at this again:

prices.filter { it >= 7 }

You know what it does. Here is the question we skipped: what, exactly, did you hand to filter?

Not a number. Not a piece of text. You handed over an instruction — a small piece of code that filter then ran, once per item, on your behalf.

That is the idea this lesson is about, and it is one of the big ones. In Kotlin, a function is a value. You can put one in a val, pass it as an argument, and get one back from another function, exactly like a number or a string.

A function with no name

A lambda is a function written inline, with no name, between braces:

1val double = { x: Int -> x * 2 }
2println(double(5))

That prints 10. Reading it left to right: the inputs, then an arrow, then what to do.

• Everything before the -> is the parameters.
• Everything after it is the body.
• The last line of the body is the result. There is no return in a lambda.

Once it is in a val, you call it with brackets like any other function: double(5).

The type of a function

double has a type, just like everything else in Kotlin. Its type is:

val double: (Int) -> Int = { it * 2 }

Read (Int) -> Int as "takes an Int, gives back an Int". Once you have written the type on the left, Kotlin knows the parameter is an Int, so you can drop it from the braces — and then it becomes available as the automatic name for the single input.

That is the whole rule behind it: one unnamed parameter, and Kotlin calls it it. With two parameters you must name them yourself:

1val add = { a: Int, b: Int -> a + b }
2println(add(2, 3))

When a lambda gives nothing back

val shout: (String) -> Unit = { println(it.uppercase()) }

Unit is Kotlin's way of writing nothing comes back. println prints and hands back nothing, so this lambda hands back nothing too. You will see () -> Unit constantly in Android: it is the type of "some code to run when something happens".

Higher-order functions

A higher-order function is one that takes a function as an input. You have used several already — filter, map and sumOf are all higher-order. Now write one:

1fun applyTwice(n: Int, f: (Int) -> Int): Int {
2  return f(f(n))
3}

The second parameter is not a number — it is a function. Inside the body, f(n) runs whatever was handed in, and the result goes straight back into f again.

println(applyTwice(3, double))

Prints 12: three doubled is six, six doubled is twelve. And because f is just a parameter, the same function does something completely different with a different slip:

println(applyTwice(3, { it * it }))

Prints 81: three squared is nine, nine squared is eighty-one.

The trailing lambda rule

That last line has an ugly , { ... }) at the end. Kotlin has a rule to fix it:

If the last argument is a lambda, you may move it outside the round brackets.

println(applyTwice(3) { it * it })

Same call, and much easier to read. If the lambda is the only argument, the brackets vanish altogether — which is why you have been writing prices.filter { it >= 7 } all along, with no brackets in sight.

This trailing lambda rule is why so much Kotlin looks like it has custom language keywords in it. It does not. repeat(3) { ... } is an ordinary function call, and so is every Compose layout you will meet in Part 3.

Why this matters for real apps

Almost everything interactive in Android is a function you hand over so that somebody else can run it later. That is called a callback:

1Button(onClick = { score = score + 1 }) {
2  Text("Roll")
3}

onClick is a parameter of type () -> Unit. You are not clicking anything now — you are handing Compose a slip of paper that says what to do when someone taps. Compose keeps it and runs it at the right moment.

Once you see that shape, an enormous amount of Android stops looking like magic. It is parameters, all the way down.

112
281
3tick 1
4tick 2
5tick 3