Summary - Higher-order functions

Combine lambdas, it and scope functions to write a processing pipeline.

Summary - Higher-order functions

In this group you learned function type, lambda, it, inline and scope functions. They all carry functions as values and enable short code.

In this summary you will write a pipeline: filter, transform and sum the numbers in a list. filter, map and sum are chained. When all parts come together you get a short, readable pipeline.

Exercise The filter-map-sum pipeline

Declare val nums = listOf(1, 2, 3, 4, 5). Declare val result = nums.filter { it % 2 == 0 }.map { it * 10 }.sum(). In main call println(result).

Show example solution

val nums = listOf(1, 2, 3, 4, 5)
val result = nums.filter { it % 2 == 0 }.map { it * 10 }.sum()

fun main() {
    println(result)
}

Exercise Configuring a list with apply

Declare val list = mutableListOf<Int>().apply { add(10); add(20); add(30) }. In main call println(list).

Show example solution

val list = mutableListOf<Int>().apply { add(10); add(20); add(30) }

fun main() {
    println(list)
}

Test yourself

Why are <code>filter</code>, <code>map</code> and <code>sum</code> chained in a pipeline?
```
Each chain step returns a list; the next step takes it.
```
- Because each requires a separate variable
- Because each step takes the previous result and produces a new one
- Because they do not compile without chaining
- Because they only work with Int
Show answer

Because each step takes the previous result and produces a new one — Each step returns a list; the next step takes it.

Complete the function type definition

val format: (Int) ____ String = { n -> "Number: $n" }

Show answer

val format: (Int) -> String = { n -> "Number: $n" }

Next lesson: Model design

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies