В чем разница между fold и reduce в Kotlin и когда что использовать?

Основное отличие: начальное значение и работа с пустыми коллекциями

Вы уже почти уловили суть. Главное различие между fold и reduce в Kotlin заключается в том, что fold требует явного начального значения (аккумулятора), а reduce использует первый элемент коллекции в качестве начального значения.

Давайте разберем это подробнее на примерах.

1. Сигнатуры функций

// reduce — принимает только лямбду
inline fun <S, T : S> Iterable<T>.reduce(
    operation: (acc: S, T) -> S
): S

// fold — принимает начальное значение и лямбду
inline fun <T, R> Iterable<T>.fold(
    initial: R,
    operation: (acc: R, T) -> R
): R

2. Что происходит под капотом?

Когда вы вызываете reduce на списке [1, 2, 3, 4, 5]:

• Первый элемент (1) становится начальным аккумулятором
• Затем применяется лямбда: (1 + 2) = 3, (3 + 3) = 6, (6 + 4) = 10, (10 + 5) = 15
• Результат: 15

Когда вы вызываете fold(0) на том же списке:

• Начальный аккумулятор = 0
• Применяется лямбда: (0 + 1) = 1, (1 + 2) = 3, (3 + 3) = 6, (6 + 4) = 10, (10 + 5) = 15
• Результат: 15

3. Проблема с пустыми коллекциями

reduce выбросит UnsupportedOperationException на пустом списке, потому что ему неоткуда взять начальное значение. fold же просто вернет переданное начальное значение:

val emptyList = listOf<Int>()
println(emptyList.fold(0) { acc, i -> acc + i }) // 0
println(emptyList.fold("Start: ") { acc, i -> "$acc$i " }) // "Start: "

4. Разница в типах

Это важный момент, который часто упускают. У reduce тип результата обязательно совпадает с типом элементов коллекции (или является его супертипом). У fold тип результата может быть любым:

val numbers = listOf(1, 2, 3, 4, 5)

// reduce — результат Int (тот же тип, что и элементы)
val sum: Int = numbers.reduce { acc, i -> acc + i }

// fold — результат может быть String!
val concatenated: String = numbers.fold("Numbers: ") { acc, i -> "$acc$i " }
println(concatenated) // "Numbers: 1 2 3 4 5 "

// А вот так reduce не сработает:
// val error = numbers.reduce { acc, i -> "$acc $i" } // Ошибка компиляции!

5. Когда что использовать?

Используйте reduce, когда:

• Вы уверены, что коллекция не пуста
• Результат должен быть того же типа, что и элементы
• Вам не нужно начальное значение (первый элемент естественным образом становится аккумулятором)
• Пример: поиск максимального/минимального элемента

val max = numbers.reduce { acc, i -> if (i > acc) i else acc }
println(max) // 5

Используйте fold, когда:

• Коллекция может быть пустой
• Тип результата отличается от типа элементов
• Вам нужно задать начальное значение (например, 0 для суммы, пустая строка для конкатенации)
• Пример: подсчет количества элементов по условию

val evenCount = numbers.fold(0) { acc, i -> if (i % 2 == 0) acc + 1 else acc }
println(evenCount) // 2 (числа 2 и 4)

6. Производительность

Обе функции имеют одинаковую сложность O(n). Разницы в производительности нет, так как обе являются inline-функциями и компилируются в одинаковый байт-код. Выбор между ними — это вопрос читаемости кода и корректности обработки граничных случаев.

7. Альтернативы

В Kotlin есть еще reduceOrNull (возвращает null для пустой коллекции) и foldIndexed/reduceIndexed (передают индекс элемента в лямбду):

val emptyList = listOf<Int>()
println(emptyList.reduceOrNull { acc, i -> acc + i }) // null

val indexedSum = numbers.foldIndexed(0) { index, acc, i -> acc + i * index }
println(indexedSum) // 0*0 + 1*1 + 2*2 + 3*3 + 4*4 = 30

Итог

Запомните простое правило: fold — это универсальный инструмент, reduce — это частный случай fold с первым элементом в качестве начального значения. Если сомневаетесь — используйте fold, он безопаснее и гибче.

// Понятно: мы начинаем с нуля
val sum = numbers.fold(0) { acc, i -> acc + i }

// Менее очевидно: первый элемент становится аккумулятором
val sum2 = numbers.reduce { acc, i -> acc + i }

val filtered = numbers.filter { it > 10 } // пустой список
// filtered.reduce { acc, i -> acc + i } // Ошибка!
filtered.fold(0) { acc, i -> acc + i } // 0 — безопасно

// reduce выглядит естественно
val max = numbers.reduce { acc, i -> maxOf(acc, i) }

// fold с первым элементом выглядит избыточно
val max2 = numbers.fold(numbers.first()) { acc, i -> maxOf(acc, i) }

val maxOrNull = numbers.reduceOrNull { acc