map, filter, reduce

fun main() {
    val numbers = listOf(1, 2, 3, 4)
    val squares = numbers.map { it * it }
    println(squares)
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6)
    val evens = numbers.filter { it % 2 == 0 }
    println(evens)
}

fun main() {
    val numbers = listOf(1, 2, 3, 4)
    val sum = numbers.reduce { acc, n -> acc + n }
    println("Sum via reduce: $sum")
}

fun main() {
    val numbers = listOf<Int>()
    val sum = numbers.fold(0) { acc, n -> acc + n }
    println("Sum via fold on empty list: $sum")

    val words = listOf("Kotlin", "is", "fun")
    val sentence = words.fold("Result:") { acc, word -> "$acc $word" }
    println(sentence)
}

1. Confusing .reduce { } with .fold(initial) { }; reduce uses the first element as the starting accumulator and throws on an empty collection, while fold takes an explicit initial value.
2. Chaining .filter { }.map { } in the wrong order and getting different (though sometimes equally valid) results than intended.
3. Forgetting these functions return a new collection or value and never mutate the original collection.

• .map { transform } returns a new list with each element transformed according to the given function.
• .filter { predicate } returns a new list containing only the elements that satisfy the given condition.
• .reduce { acc, item -> ... } combines all elements into a single result, using the first element as the initial accumulator.
• .fold(initial) { acc, item -> ... } is like reduce but takes an explicit starting value, so it also works on empty collections.