# How to Use Swift Reduce to Calculate the Sum of an Array of Integers

> Easily calculate integer array sums in Swift using the reduce method. Learn the shorthand method for efficient aggregation and improve your Swift coding skills.

- Repository: [Apple/swift](https://github.com/apple/swift)
- Tags: how-to-guide
- Published: 2026-02-16

---

**Use the `reduce(_:_:)` method on any `Array<Int>` by passing `0` as the initial result and a closure that adds the accumulator to each element, such as `numbers.reduce(0) { $0 + $1 }` or the shorthand `numbers.reduce(0, +)`.**

The `reduce` method is a fundamental aggregation operation in the Swift standard library that transforms a sequence into a single value. When working with the `apple/swift` repository, you can leverage this generic algorithm defined in [`stdlib/public/core/SequenceAlgorithms.swift`](https://github.com/apple/swift/blob/main/stdlib/public/core/SequenceAlgorithms.swift) to efficiently calculate the sum of an array of integers using functional programming patterns.

## Understanding the Reduce Algorithm in Swift

Swift’s `reduce` implementation lives in **[`stdlib/public/core/SequenceAlgorithms.swift`](https://github.com/apple/swift/blob/main/stdlib/public/core/SequenceAlgorithms.swift)** (lines 668–678) and operates on any type conforming to the `Sequence` protocol. The algorithm works by maintaining a mutable accumulator, iterating through each element, and applying a combining closure.

The implementation follows **O(n)** time complexity where *n* is the number of elements:

```swift
public func reduce<Result>(
    _ initialResult: Result,
    _ nextPartialResult: (_ partialResult: Result, Element) throws -> Result
) rethrows -> Result {
    var accumulator = initialResult
    for element in self {
        accumulator = try nextPartialResult(accumulator, element)
    }
    return accumulator
}

```

When summing integers, the `Result` type resolves to `Int`, the `initialResult` becomes your starting value (typically `0`), and the closure performs addition.

## Practical Code Examples for Summing Arrays

### Basic Closure Syntax

The most explicit approach uses a trailing closure to add the running total to each new element:

```swift
let numbers = [3, 7, 2, 9, 4]
let total = numbers.reduce(0) { $0 + $1 }
print(total)  // → 25

```

Here, `$0` represents the accumulated sum and `$1` represents the current integer from the array.

### Using the Plus Operator

Swift allows passing the `+` operator directly as the combining function, creating a concise one-liner:

```swift
let total2 = numbers.reduce(0, +)
print(total2)  // → 25

```

This leverages Swift’s operator functions where `+` satisfies the signature `(Int, Int) -> Int` required by `nextPartialResult`.

### Explicit Type Annotations

When the compiler cannot infer the result type, explicitly annotate the accumulator parameters:

```swift
let total3: Int = numbers.reduce(0) { (running, next) in
    running + next
}
print(total3)  // → 25

```

This syntax is particularly useful in complex generic contexts or when working with custom numeric types.

### In-Place Reduction with reduce(into:)

For copy-on-write types or when mutating an accumulator is more efficient, use `reduce(into:)`:

```swift
let total4 = numbers.reduce(into: 0) { (running: inout Int, next: Int) in
    running += next
}
print(total4)  // → 25

```

This variant passes the accumulator as an `inout` parameter, avoiding intermediate copies during the reduction process.

## How Reduce Works Under the Hood

According to the `apple/swift` source code in **[`stdlib/public/core/SequenceAlgorithms.swift`](https://github.com/apple/swift/blob/main/stdlib/public/core/SequenceAlgorithms.swift)**, the `reduce` method initializes a mutable `accumulator` with your `initialResult`, then iterates through the sequence using a `for` loop. For each element, it invokes the `nextPartialResult` closure, updating the accumulator with the returned value.

This design ensures that `reduce` works uniformly across all `Sequence` conforming types, including `Array`, `Set`, and `Dictionary` values. The algorithm maintains **O(n)** complexity because it performs exactly one closure invocation per element.

## Summary

- **Swift's `reduce`** is defined in [`stdlib/public/core/SequenceAlgorithms.swift`](https://github.com/apple/swift/blob/main/stdlib/public/core/SequenceAlgorithms.swift) and works on any `Sequence` conforming type.
- **Calculate sums** by passing `0` as the initial result and a closure that adds the accumulator to each element.
- **Use shorthand syntax** like `numbers.reduce(0, +)` for concise, readable code.
- **Consider `reduce(into:)`** when working with copy-on-write types for better performance.
- **Complexity is O(n)**, making it efficient for summing arrays of any size.

## Frequently Asked Questions

### What is the time complexity of Swift's reduce method?

Swift's `reduce` method operates with **O(n)** time complexity where *n* is the number of elements in the sequence. According to the implementation in [`stdlib/public/core/SequenceAlgorithms.swift`](https://github.com/apple/swift/blob/main/stdlib/public/core/SequenceAlgorithms.swift), the method performs a single pass through the sequence, invoking the combining closure exactly once per element.

### Can I use reduce with other numeric types like Double or Float?

Yes, `reduce` works with any type that satisfies the closure requirements, including `Double`, `Float`, `CGFloat`, and custom numeric types conforming to `Numeric`. Simply adjust the initial result type: `[1.5, 2.5, 3.0].reduce(0.0, +)` produces a `Double` result of `6.0`.

### What is the difference between reduce and reduce(into:) in Swift?

`reduce(_:_:)` creates a new value for each iteration by copying the accumulator, while `reduce(into:)` passes the accumulator as an `inout` parameter, allowing mutation in place. For value types like `Int`, both perform similarly, but `reduce(into:)` offers better performance when accumulating into copy-on-write collections like `Array` or `Dictionary`.

### Is reduce the most efficient way to sum an array in Swift?

For simple integer summation, `reduce` is efficient at **O(n)** complexity, but Swift's `sum()` method (available on `Sequence` when `Element` conforms to `AdditiveArithmetic`) provides a more readable alternative with identical performance characteristics. Both ultimately iterate through the sequence once, but `sum()` expresses intent more clearly for this specific operation.