The reduce function reduces a list into a single value. Often referred to as fold or aggregate, it takes two parameters: a starting value and a function.

A function takes a running total and an element of the list as parameters and returns a value that is created by combining the elements in the list.

Unlike map, filter, and flatMap, which would return the same type, reduce changes the type. In other words, map, filter, and flatMap would take an array and provide a changed array. This is not the case with reduce as it can change an array to, for instance, a tuple or single value.

Swift provides the reduce method on sequences and has the following definition:

public func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result 

If we use the reduce method on our numbers array, the result of this call becomes 394:

let total = numbers.reduce(0) { $0 + $1 } 

We could also call reduce, as follows, as the + operator is a function in Swift:

let total = numbers.reduce(0, +) 

Like the map and filter methods, developing a reduce function is also simple:

func reduce<Element, Value>(elements: [Element], 
                            initial: Value, 
                            combine: (Value, Element) -> Value) -> Value { 

    var result = initial 
    for element in elements { 
        result = combine(result, element) 
    } 

    return result 
} 

We can achieve the same result (394) with the following call:

let total = reduce(elements: numbers, initial: 0) { $0 + $1 } 

The reduce method can be used with other types, such as arrays of Strings.