If you need to create a single value from a sequence of elements, then the `reduce(_:_:)`

method is the API you are looking for. In this episode of **Swift Fundamentals**, we take a look at Swift's `reduce(_:_:)`

method. You learn about its syntax and when you shouldn't use it.

## How to Use the reduce(*:*:) Method?

Fire up Xcode and create a playground by choosing the **Blank** template from the **iOS > Playground** section if you want to follow along.

The `reduce(_:_:)`

method is defined on sequences, such as sets, arrays, and dictionaries. Let's start with an array of numbers.

```
import Foundation
let numbers = [1, 3, 8, 2, 34]
```

We can use the `reduce(_:_:)`

method to produce a single value from the array of numbers. Let's use the `reduce(_:_:)`

method to calculate the sum of .

The `reduce(_:_:)`

method accepts two arguments, an initial result and a closure. The closure is executed for every element of the sequence. The closure accepts two arguments, the partial result and an element of the sequence, and it returns a new partial result. The partial result the closure returns is passed in as the first argument of the closure the next time the closure is executed.

In this example, we set the initial result to `0`

. In the closure we pass to the `reduce(_:_:)`

method, we add the element that is passed to the closure, an integer, to the partial result and return the result of the sum. The closure is executed five times because the sequence contains five elements. The partial result is `0`

when the closure is executed for the first time and the closure returns `1`

. The partial result is `1`

when the closure is executed for the second time and the closure returns `4`

, the sum of the partial result, `1`

, and the element, `3`

. The `reduce(_:_:)`

method returns the result, which is the sum of the elements of the `numbers`

array.

```
import Foundation
let numbers = [1, 3, 8, 2, 34]
let sum = numbers.reduce(0) { partialResult, number in
partialResult + number
}
```

The `reduce(_:_:)`

method has many more applications. The only requirement is that the type of the initial result is the same as the type of the value the closure returns. Let's calculate the maximum value of the elements of the `numbers`

array.

```
import Foundation
let numbers = [1, 3, 8, 2, 34]
let max = numbers.reduce(0) { partialResult, number in
if number > partialResult {
return number
} else {
return partialResult
}
}
```

## Why Not a for Loop?

You could use a `for`

loop to achieve the same result. Take a look at this example. Is this a better implementation? I think that is debatable. I prefer the implementation to be concise and focused. If we use a `for`

loop, we need to declare a variable to hold the partial result while that is nicely encapsulated by the `reduce(_:_:)`

method.

```
import Foundation
let numbers = [1, 3, 8, 2, 34]
var sum = 0
for number in numbers {
sum += number
}
```

We can further clean up the implementation that uses the `reduce(_:_:)`

method by using shorthand argument names. This looks quite nice. Right?

```
import Foundation
let numbers = [1, 3, 8, 2, 34]
let sum = numbers.reduce(0) { $0 + $1 }
```

We can do the same to calculate the maximum value of `numbers`

array. While this is more concise, it isn't easy to understand due to the use of shorthand argument names and ternary operator.

```
import Foundation
let numbers = [1, 3, 8, 2, 34]
let max = numbers.reduce(0) { $0 < $1 ? $1 : $0 }
```

## Reducing Dictionaries

The `reduce(_:_:)`

method can also be used on dictionaries. In this example, we have a dictionary with keys of type `String`

and values of type `Int`

. The key is the name of a person and the value is the person's age. Let's find out what the age is of the oldest person of the group.

```
import Foundation
let people = [
"Jane": 19,
"John": 25,
"Lucy": 25,
"Mike": 21,
"Matt": 39,
"Sarah": 28
]
let person = people.reduce(0) { partialResult, element in
if partialResult < element.value {
return element.value
} else {
return partialResult
}
}
```

## Reducing Sets

The `Set`

struct is a sequence and therefore also defines a `reduce(_:_:)`

method. The idea is similar to what we previously covered.

```
import Foundation
let numbers: Set<Int> = [1, 2, 3, 4, 5]
let sum = numbers.reduce(0) { partialResult, number in
partialResult + number
}
```

## When Not to Use the reduce(*:*:) Method

As with every tool, you need to know when *not* to use it. The `reduce(_:_:)`

method can be used for a variety of tasks, but the common theme is producing a single value from a sequence of elements, such as sets, arrays, and dictionaries. Don't use it to map or filter the values of a sequence of elements. Take a look at this example.

```
import Foundation
let numbers = [1, 3, 8, 2, 34]
let evenNumbers = numbers.reduce(Array<Int>()) { partialResult, number in
if number % 2 == 0 {
return partialResult + [number]
}
return partialResult
}
```

We use the `reduce(_:_:)`

method to filter out odd numbers from the `numbers`

array. I hope you agree that the implementation feels a bit odd and the `reduce(_:_:)`

method isn't the best tool for the task. Take a look at this example in which we use the `filter(_:)`

method to achieve the same result.

```
import Foundation
let numbers = [1, 3, 8, 2, 34]
let evenNumbers = numbers.filter { $0 % 2 == 0 }
```

## What's Next?

The `reduce(_:_:)`

method is a useful tool to produce a single value from a sequence of elements. The syntax is easy to pick up and you can use it in a range of use cases.