Kotlin provides powerful collection functions that make data manipulation intuitive and efficient. Among them, fold and filter stand out as essential tools for transforming and processing collections. In this guide, we’ll explore these functions in depth, providing detailed explanations and practical examples to help you leverage their full potential.

Understanding the fold Function in Kotlin

The fold function is a powerful tool that allows you to accumulate values from a collection into a single result. It is particularly useful when you need to perform operations like summation, product calculation, or concatenation.

Syntax of fold

fun <T, R> Iterable<T>.fold(initial: R, operation: (acc: R, T) -> R): R

• initial: The starting value for accumulation.
• operation: A lambda function that takes an accumulator (acc) and the current element (T), and returns a new accumulated value.

Summing a List

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

How it works:

• The initial value is 0.
• Each number is added to acc, updating it with every iteration.
• The final accumulated value is 15.

Concatenating Strings

val words = listOf("Hello", "World", "Kotlin")
val sentence = words.fold("") { acc, word -> "$acc $word" }.trim()
println(sentence) // Output: Hello World Kotlin

• The initial value is an empty string "".
• Each word is appended to the accumulator with a space.
• The .trim() ensures no leading space in the final string.

Understanding the filter Function in Kotlin

The filter function is used to extract elements from a collection based on a specified condition. It returns a new list containing only the elements that satisfy the predicate.

Syntax of filter

fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>

• predicate: A lambda function that evaluates each element and returns true if it should be included in the output list.

Filtering Even Numbers

val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val evenNumbers = numbers.filter { it % 2 == 0 }
println(evenNumbers) // Output: [2, 4, 6, 8, 10]

• The lambda function it % 2 == 0 checks if each number is even.
• The function returns a new list containing only even numbers.

Filtering Long Words

val words = listOf("Kotlin", "Java", "C", "Python", "Go", "Swift")
val longWords = words.filter { it.length >= 5 }
println(longWords) // Output: [Kotlin, Python, Swift]

• The condition it.length >= 5 ensures that only words with 5 or more letters are included.
• The function returns a new list with the filtered words.

Combining filter and fold for Advanced Processing

Using filter and fold together can help in performing complex operations efficiently. Let’s look at a few practical examples:

Summing Only Even Numbers

val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val sumOfEvenNumbers = numbers.filter { it % 2 == 0 }.fold(0) { acc, num -> acc + num }
println(sumOfEvenNumbers) // Output: 30

1. filter { it % 2 == 0 } → Extracts only even numbers [2, 4, 6, 8, 10].
2. fold(0) { acc, num -> acc + num } → Accumulates the sum, resulting in 30.

Concatenating Long Words

val words = listOf("Kotlin", "Java", "C", "Python", "Go", "Swift")
val concatenatedWords = words.filter { it.length >= 5 }.fold("") { acc, word -> "$acc $word" }.trim()
println(concatenatedWords) // Output: Kotlin Python Swift

1. filter { it.length >= 5 } → Filters words with 5 or more letters.
2. fold("") { acc, word -> "$acc $word" } → Concatenates the words into a single string.
3. .trim() → Removes unnecessary spaces at the beginning and end.

When to Use fold vs. filter?

Conclusion

Both fold and filter are essential functions in Kotlin for working with collections efficiently. While filter helps in selecting specific elements, fold allows you to transform them into a single result. Combining them enables powerful and readable operations, making your Kotlin code more concise and expressive.