kotlin-stdlib/kotlin.collections/fold

fold

inline fun <T, R> Array<out T>.fold(initial: R, operation: (acc: R, T) -> R): R(source)
inline fun <R> ByteArray.fold(initial: R, operation: (acc: R, Byte) -> R): R(source)
inline fun <R> ShortArray.fold(initial: R, operation: (acc: R, Short) -> R): R(source)
inline fun <R> IntArray.fold(initial: R, operation: (acc: R, Int) -> R): R(source)
inline fun <R> LongArray.fold(initial: R, operation: (acc: R, Long) -> R): R(source)
inline fun <R> FloatArray.fold(initial: R, operation: (acc: R, Float) -> R): R(source)
inline fun <R> DoubleArray.fold(initial: R, operation: (acc: R, Double) -> R): R(source)
inline fun <R> BooleanArray.fold(initial: R, operation: (acc: R, Boolean) -> R): R(source)
inline fun <R> CharArray.fold(initial: R, operation: (acc: R, Char) -> R): R(source)

Accumulates value starting with initial value and applying operation from left to right to current accumulator value and each element.

Returns the specified initial value if the array is empty.

Since Kotlin

1.0

Parameters

operation

function that takes current accumulator value and an element, and calculates the next accumulator value.

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

Accumulates value starting with initial value and applying operation from left to right to current accumulator value and each element.

Returns the specified initial value if the collection is empty.

Since Kotlin

1.0

Parameters

operation

function that takes current accumulator value and an element, and calculates the next accumulator value.

@ExperimentalUnsignedTypes
inline fun <R> UIntArray.fold(initial: R, operation: (acc: R, UInt) -> R): R(source)
@ExperimentalUnsignedTypes
inline fun <R> ULongArray.fold(initial: R, operation: (acc: R, ULong) -> R): R(source)
@ExperimentalUnsignedTypes
inline fun <R> UByteArray.fold(initial: R, operation: (acc: R, UByte) -> R): R(source)
@ExperimentalUnsignedTypes
inline fun <R> UShortArray.fold(initial: R, operation: (acc: R, UShort) -> R): R(source)

Accumulates value starting with initial value and applying operation from left to right to current accumulator value and each element.

Returns the specified initial value if the array is empty.

Since Kotlin

1.3

Parameters

operation

function that takes current accumulator value and an element, and calculates the next accumulator value.

inline fun <T, K, R> Grouping<T, K>.fold(initialValueSelector: (key: K, element: T) -> R, operation: (key: K, accumulator: R, element: T) -> R): Map<K, R>(source)

Groups elements from the Grouping source by key and applies operation to the elements of each group sequentially, passing the previously accumulated value and the current element as arguments, and stores the results in a new map. An initial value of accumulator is provided by initialValueSelector function.

Since Kotlin

1.1

Return

a Map associating the key of each group with the result of accumulating the group elements.

Parameters

initialValueSelector

a function that provides an initial value of accumulator for each group. It's invoked with parameters:

  • key: the key of the group;

  • element: the first element being encountered in that group.

operation

a function that is invoked on each element with the following parameters:

  • key: the key of the group this element belongs to;

  • accumulator: the current value of the accumulator of the group;

  • element: the element from the source being accumulated.

Samples


fun main() { 
   //sampleStart 
   val fruits = listOf("cherry", "blueberry", "citrus", "apple", "apricot", "banana", "coconut")

val evenFruits = fruits.groupingBy { it.first() }
    .fold({ key, _ -> key to mutableListOf<String>() },
          { _, accumulator, element ->
              accumulator.also { (_, list) -> if (element.length % 2 == 0) list.add(element) }
          })

val sorted = evenFruits.values.sortedBy { it.first }
println(sorted) // [(a, []), (b, [banana]), (c, [cherry, citrus])] 
   //sampleEnd
}
inline fun <T, K, R> Grouping<T, K>.fold(initialValue: R, operation: (accumulator: R, element: T) -> R): Map<K, R>(source)

Groups elements from the Grouping source by key and applies operation to the elements of each group sequentially, passing the previously accumulated value and the current element as arguments, and stores the results in a new map. An initial value of accumulator is the same initialValue for each group.

Since Kotlin

1.1

Return

a Map associating the key of each group with the result of accumulating the group elements.

Parameters

operation

a function that is invoked on each element with the following parameters:

  • accumulator: the current value of the accumulator of the group;

  • element: the element from the source being accumulated.

Samples


fun main() { 
   //sampleStart 
   val fruits = listOf("apple", "apricot", "banana", "blueberry", "cherry", "coconut")

// collect only even length Strings
val evenFruits = fruits.groupingBy { it.first() }
    .fold(listOf<String>()) { acc, e -> if (e.length % 2 == 0) acc + e else acc }

println(evenFruits) // {a=[], b=[banana], c=[cherry]} 
   //sampleEnd
}