# Functional Programming in Kotlin: Most Common Higher-Order Functions

In the previous part of the series, we explored the concept of higher-order functions in Kotlin and saw how they can be used to write more concise and expressive code. In this article, we'll dive deeper into some of the most commonly used higher-order functions in Kotlin and see how they can simplify your code.

`map()`

The `map()`

function is used to transform a collection of elements of one type into a collection of elements of another type. It takes a lambda function as an argument, which is applied to each element in the collection. The result is a new collection with the transformed elements.

```
val numbers = listOf(1, 2, 3, 4, 5)
val squares = numbers.map { it * it }
println(squares) // [1, 4, 9, 16, 25]
```

In this example, we use the `map()`

function to transform a list of integers into a list of their squares.

`filter()`

The `filter()`

function is used to filter a collection based on a predicate. It takes a lambda function as an argument, which returns `true`

or `false`

for each element in the collection. The result is a new collection with only the elements for which the predicate returned `true`

.

```
val numbers = listOf(1, 2, 3, 4, 5)
val evenNumbers = numbers.filter { it % 2 == 0 }
println(evenNumbers) // [2, 4]
```

In this example, we use the `filter()`

function to filter a list of integers and keep only the even numbers.

`fold()`

The `fold()`

function is used to accumulate the elements of a collection into a single result value. It takes an initial value and a lambda function as arguments. The lambda function takes two arguments: an accumulator and the next element of the collection. The result of the lambda function is the new value of the accumulator. The final result is the value of the accumulator after all elements have been processed.

```
val numbers = listOf(1, 2, 3, 4, 5)
val sum = numbers.fold(0) { acc, number -> acc + number }
println(sum) // 15
```

In this example, we use the `fold()`

function to calculate the sum of a list of integers.

`reduce()`

This function is similar to `fold`

, but does not take an initial value. The first element of the collection is used as the initial value and the operation is applied to the remaining elements.

```
val numbers = listOf(1, 2, 3, 4, 5)
val product = numbers.reduce { acc, n -> acc * n }
println(product)
// Output: 120
```

`groupBy()`

This function groups the elements of a collection by a given key selector function and returns a map of the keys and the corresponding values

```
val numbers = listOf(1, 2, 3, 4, 5, 6)
val evenOddMap = numbers.groupBy { if (it % 2 == 0) "even" else "odd" }
println(evenOddMap)
// Output: {odd=[1, 3, 5], even=[2, 4, 6]}
```

`takeWhile()`

This function returns a new list of elements from the beginning of the given collection that satisfy the given predicate until an element that does not satisfy it is found.

```
val numbers = listOf(1, 2, 3, 4, 5, 6)
val firstThree = numbers.takeWhile { it < 4 }
println(firstThree)
// Output: [1, 2, 3]
```

`dropWhile()`

This function returns a new list of elements from the given collection starting from the first element that does not satisfy the given predicate.

```
val numbers = listOf(1, 2, 3, 4, 5, 6)
val remainingNumbers = numbers.dropWhile { it < 4 }
println(remainingNumbers)
// Output: [4, 5, 6]
```

### Composing

The ability to compose higher-order functions is one of the key benefits of functional programming. It allows for the creation of complex operations by combining simple building blocks. This approach can help to reduce the complexity of code, make it easier to reason about, and enable the creation of reusable code.

Take a look at this sample:

```
fun main() {
val numbers = listOf(1, 2, 3, 4, 5)
val result = numbers.filter { it % 2 == 0 }
.map { it * it }
.reduce { acc, i -> acc + i }
println("The sum of the squares of the even numbers is: $result")
}
```

here, we start with a list of integers and filter out the odd numbers using the `filter`

higher-order function. We then use the `map`

function to square each of the remaining even numbers. Finally, we use the `reduce`

function to add up all the squared even numbers, resulting in the sum of the squares of the even numbers. This is just one example of how you can compose higher-order functions in Kotlin to achieve powerful and concise functionality.

Can you guess the result?

### Wrapping up

In this article, we've explored some of the most commonly used high order functions in Kotlin, including filter, map, fold, and flatMap. We've seen how these functions can be used to simplify code and create more expressive and readable programs. We've also discussed how these functions can be composed together to create complex operations that are easy to understand and modify. By using high order functions effectively, we can write code that is more concise, efficient, and maintainable. In the next part of this series, we'll dive into other concepts of Functional Programming in Kotlin.

Stay tuned