Generic Instance Method

reduce(_:_:)

Returns the result of combining the elements of the sequence using the given closure.

Declaration

func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, (key: Key, value: Value)) throws -> Result) rethrows -> Result

Parameters

initialResult

The value to use as the initial accumulating value. initialResult is passed to nextPartialResult the first time the closure is executed.

nextPartialResult

A closure that combines an accumulating value and an element of the sequence into a new accumulating value, to be used in the next call of the nextPartialResult closure or returned to the caller.

Return Value

The final accumulated value. If the sequence has no elements, the result is initialResult.

Discussion

Use the reduce(_:_:) method to produce a single value from the elements of an entire sequence. For example, you can use this method on an array of numbers to find their sum or product.

The nextPartialResult closure is called sequentially with an accumulating value initialized to initialResult and each element of the sequence. This example shows how to find the sum of an array of numbers.

let numbers = [1, 2, 3, 4]
let numberSum = numbers.reduce(0, { x, y in
    x + y
})
// numberSum == 10

When numbers.reduce(_:_:) is called, the following steps occur:

  1. The nextPartialResult closure is called with initialResult0 in this case—and the first element of numbers, returning the sum: 1.

  2. The closure is called again repeatedly with the previous call’s return value and each element of the sequence.

  3. When the sequence is exhausted, the last value returned from the closure is returned to the caller.

If the sequence has no elements, nextPartialResult is never executed and initialResult is the result of the call to reduce(_:_:).

Complexity: O(n), where n is the length of the sequence.

See Also

Transforming a Dictionary

func mapValues<T>((Value) -> T) -> Dictionary<Key, T>

Returns a new dictionary containing the keys of this dictionary with the values transformed by the given closure.

func reduce<Result>(into: Result, (inout Result, (key: Key, value: Value)) -> ()) -> Result

Returns the result of combining the elements of the sequence using the given closure.

func map<T>(((key: Key, value: Value)) -> T) -> [T]

Returns an array containing the results of mapping the given closure over the sequence’s elements.

func compactMap<ElementOfResult>(((key: Key, value: Value)) -> ElementOfResult?) -> [ElementOfResult]

Returns an array containing the non-nil results of calling the given transformation with each element of this sequence.

func compactMapValues<T>((Value) -> T?) -> Dictionary<Key, T>

Returns a new dictionary containing only the key-value pairs that have non-nil values as the result of transformation by the given closure.

func flatMap<SegmentOfResult>(((key: Key, value: Value)) -> SegmentOfResult) -> [SegmentOfResult.Element]

Returns an array containing the concatenated results of calling the given transformation with each element of this sequence.

func sorted(by: ((key: Key, value: Value), (key: Key, value: Value)) -> Bool) -> [(key: Key, value: Value)]

Returns the elements of the sequence, sorted using the given predicate as the comparison between elements.

func shuffled() -> [(key: Key, value: Value)]

Returns the elements of the sequence, shuffled.

func shuffled<T>(using: inout T) -> [(key: Key, value: Value)]

Returns the elements of the sequence, shuffled using the given generator as a source for randomness.