Oliver Foggin - functional-programming

Functional Thinking in Swift: Part 3 - The power of Reduce

2026-03-07T00:00:00+00:00

In Part 2</a> we looked at filter</code> and reduce</code> and how we can use them to shape the data that we start with. Removing elements with filter</code> or even combining them like adding numbers with reduce</code>.</p>

In this part we will show how reduce</code> is the powerhouse of the functional tools available. How it can be used to perform the same tasks that filter</code> and map</code> perform, but can also be used to create some really powerful ways of manipulating data.</p>

Map with reduce

#</span></a>
</h2>
To show how reduce</code> is really the primitive function that can be used to derive others, let's look at how we might map</code> an array and convert that to reduce</code>.</p>
let</span> numbers </span>=</span> [</span>1</span>, </span>2</span>, </span>3</span>, </span>4</span>]</span></span>
</span>
// The Map version</span></span>
let</span> doubled </span>=</span> numbers.</span>map</span> {</span> $0</span> *</span> 2</span> }</span></span>
</span>
// The Reduce version</span></span>
let</span> doubledWithReduce </span>=</span> numbers.</span>reduce</span>(</span>into</span>:</span> []</span>) {</span> acc, number </span>in</span></span>
  acc.</span>append</span>(</span>number </span>*</span> 2</span>)</span></span>
}</span></span></code></pre>
Here we can see that map</code> is just a specific implementation of reduce</code> where the accumulator is a new array and each operation appends into that new array.</p>
Filter with reduce#</span></a>
</h2>
Just as with map</code>, we can also perform a filter</code> with reduce</code>.</p>
let</span> numbers </span>=</span> [</span>1</span>, </span>2</span>, </span>3</span>, </span>4</span>]</span></span>
</span>
// The Filter version</span></span>
let</span> evens </span>=</span> numbers.</span>filter</span> {</span> $0.</span>isMultiple</span>(</span>of</span>:</span> 2</span>) }</span></span>
</span>
// The Reduce version</span></span>
let</span> evensWithReduce </span>=</span> numbers.</span>reduce</span>(</span>into</span>:</span> []</span>) {</span> acc, number </span>in</span></span>
  if</span> number.</span>isMultiple</span>(</span>of</span>:</span> 2</span>) {</span></span>
    acc.</span>append</span>(</span>number</span>)</span></span>
  }</span></span>
}</span></span></code></pre>
You can see a similar pattern here that we used for map</code>. We start from an empty array, but this time we only append if the number matches our condition.</p>
Reduce() and Reduce(into:)#</span></a>
</h2>
In both these examples we use reduce(into: [])</code>. This gives us an inout</code> value that we can mutate in the closure and can be more performant when we're returning a collection.</p>
The alternative is to use the version reduce([])</code>, in which we still provide an initial value, but this is not mutable in the closure and we must return the new value. This is better for use when we're reducing into a single value like summing an array of ints.</p>
Partitioning by value#</span></a>
</h2>
Here we've seen reduce</code> not just outputting a single value but an array. We can go further by really pushing the power of reduce</code>.</p>
If we have an array of dates, we might want to split those dates into groups of the same calendar month. At first this seems like it might be easier to start building up from scratch the imperative way. Start with an empty array, create a new array to build up the first month, then append to the parent array when reaching a new month, etc.</p>
But we can reduce (pun intended) this down in complexity and solve the problem once so that we can partition any sorted array into like groups.</p>
Thinking in data pipelines#</span></a>
</h2>
When using functional ideas I often find it easier to think about data pipelines. That is, what is it that we want to get out of the data at each point.</p>
For this problem we start with a sorted array of dates:</p>
[date1, date2, date3, </span>...</span>, dateN]</span></span></code></pre>
And out of it we want a nested array of dates where each subarray contains dates from the same calendar month.</p>
[[date1, date2], [date3, date4, date5], </span>...</span>, [</span>...</span>, dateN]]</span></span></code></pre>
As we work along the input we're going to have to ask ourselves what are the states we can be in? In this case, there are three possible states.</p>

The output array is empty. We haven't started yet.</li>
The last sub-array of the output array contains dates in the same month as the next date.</li>
The last sub-array of the output array contains dates in a different month as the next date.</li>
</ul>
In the above cases we can deal with each by:</p>

Just append a new array with the next date in it.</li>
Append the next date into the last sub-array.</li>
Just append a new array with the next date in it.</li>
</ul>
We can see that 1 and 3 require the same work, so we can combine these. Once we have these written down we can start to implement the grouping function.</p>
let</span> sortedDates:</span> [</span>Date</span>]</span> = ...</span></span>
</span>
// We know we need a nested array.</span></span>
let</span> groupedByMonth:</span> [[</span>Date</span>]]</span> =</span> sortedDates.</span>reduce</span>(</span>into</span>:</span> []</span>) {</span> acc, next </span>in</span></span>
  // First deal with case 2.</span></span>
  if let</span> lastDate </span>=</span> acc.last</span>?</span>.last,</span></span>
     Calendar.current.</span>isDate</span>(</span>next, </span>equalTo</span>:</span> lastDate, </span>toGranularity</span>:</span> .month</span>)</span></span>
  {</span></span>
    acc</span>[</span>acc.count</span> -</span> 1</span>]</span>.</span>append</span>(</span>next</span>)</span></span>
  }</span> else</span> {</span></span>
    // Everything else goes in here.</span></span>
    acc.</span>append</span>(</span>[next]</span>)</span></span>
  }</span></span>
}</span></span></code></pre>
This is great, but what if we want to group by dates in the same day, or year? Or what if we want to group by something else completely? Perhaps we want to group students by grade boundaries?</p>
Extracting the logic#</span></a>
</h2>
When working with functional patterns we often find that once we've written something like the above we can dissect it to remove the specifics about that scenario but still keep the logic around what it's doing.</p>
In this case, the specific logic is the check that the next date is in the same month as the last. Everything else is just the work to build the chunked array.</p>
We can extract that and allow the developer to provide that logic for us. Let's create a new group</code> function that does just this by providing a closure. The only thing we need to know is, given two elements, should they be in the same group or different. So we need two elements in and a bool out.</p>
extension</span> Array</span> {</span></span>
  // This is our new function with our closure.</span></span>
  func</span> group</span>(</span>by</span> matches</span>: </span>(</span>Element</span>, </span>Element</span>)</span> -></span> Bool</span>)</span> -></span> [[</span>Element</span>]] {</span></span>
    // Here we can use the same reduce but generalise it with the closure.</span></span>
    reduce</span>(</span>into</span>:</span> []</span>) {</span> acc, next </span>in</span></span>
      if let</span> prev </span>=</span> acc.last</span>?</span>.last,</span></span>
         matches</span>(</span>prev, next</span>) {</span></span>
        acc</span>[</span>acc.count</span> -</span> 1</span>]</span>.</span>append</span>(</span>next</span>)</span></span>
      }</span> else</span> {</span></span>
        acc.</span>append</span>(</span>[next]</span>)</span></span>
      }</span></span>
    }</span></span>
  }</span></span>
}</span></span>
</span>
let</span> sortedDates </span>=</span> [</span>...</span>]</span></span>
</span>
// Now we can group by month.</span></span>
let</span> groupedByMonth </span>=</span> sortedDates.</span>group</span> {</span></span>
  Calendar.current.</span>isDate</span>(</span>$0, </span>equalTo</span>:</span> $1, </span>toGranularity</span>:</span> .month</span>)</span></span>
}</span></span>
</span>
// Or we can group by day.</span></span>
let</span> groupedByDay </span>=</span> sortedDates.</span>group</span> {</span></span>
  Calendar.current.</span>isDate</span>(</span>$0, </span>equalTo</span>:</span> $1, </span>toGranularity</span>:</span> .day</span>)</span></span>
}</span></span>
</span>
// Or we can sort by something else entirely.</span></span>
let</span> groupedByGradeBoundary </span>=</span> sortedStudents.</span>group</span> {</span></span>
  $0.grade</span> ==</span> $1.grade</span></span>
}</span></span></code></pre>
By doing this we have created a reusable chunking algorithm that we can take to any project and reuse any time we need to chunk our data this way.</p>
We could even chain this together to group by year then month.</p>
let</span> monthYearGroups </span>=</span> sortedDates</span></span>
  .</span>group</span> {</span> last, next </span>in</span> // (Date, Date) -> Bool</span></span>
    Calendar.current.</span>isDate</span>(</span>next, </span>equalTo</span>:</span> last, </span>toGranularity</span>:</span> .month</span>)</span></span>
  }</span></span>
  .</span>group</span> {</span> last, next </span>in</span> // ([Date], [Date]) -> Bool</span></span>
    // This algorithm ensures that both values have at least one element,</span></span>
    // so we can safely force unwrap the first.</span></span>
    Calendar.current.</span>isDate</span>(</span>next.first</span>!</span>, </span>equalTo</span>:</span> last.first</span>!</span>, </span>toGranularity</span>:</span> .year</span>)</span></span>
  }</span></span></code></pre>
This small reusable function that we have created has encapsulated the work of grouping arrays into matching groups and allowed us to put the hard work in up front of understanding the problem and finding a solution.</p>
When to build functional tools#</span></a>
</h2>
Building functional tools like this builds up a toolkit of functions that can be used across multiple projects and each one is solved, tested, verified, and ready to be plugged in to your data.</p>
The trigger for building a function like this is boilerplate friction. If you find yourself writing the scaffolding, the empty arrays, the loops, the index management, more than the actual business logic, you've found a candidate for a functional tool. Move the how into an extension so your main code can stay focused on the what.</p>



Functional Thinking in Swift: Part 2 - Filter & Reduce
2025-12-23T00:00:00+00:00
In Part 1</a> we looked at map</code> and how it helps us transform data. But transforming data is only half the battle; often, we need to narrow down our datasets or combine them into a single value. This is where filter</code> and reduce</code> come in.</p>
We will look at how filter</code> and reduce</code> work on their own and what they do, but then also how we can compose these functions together to unlock the "super power" of functional thinking in Swift.</p>
Filter: The Gatekeeper#</span></a>
</h2>
The filter</code> function does exactly what it says on the tin: it takes a collection and returns a new collection containing only the elements that satisfy a specific condition.</p>
The Imperative Way#</span></a>
</h3>
Before functional patterns, we would create a "mutable bucket," loop through our data, and manually append items that meet our criteria.</p>
let</span> numbers </span>=</span> [</span>1</span>, </span>2</span>, </span>3</span>, </span>4</span>, </span>5</span>, </span>6</span>, </span>7</span>, </span>8</span>, </span>9</span>, </span>10</span>]</span></span>
var</span> evenNumbers:</span> [</span>Int</span>]</span> =</span> []</span></span>
</span>
for</span> number </span>in</span> numbers </span>{</span></span>
  if</span> number </span>%</span> 2</span> ==</span> 0</span> {</span></span>
    evenNumbers.</span>append</span>(</span>number</span>)</span></span>
  }</span></span>
}</span></span>
// result: [2, 4, 6, 8, 10]</span></span></code></pre>The Functional Way#</span></a>
</h3>
With filter</code>, we get rid of the "how" (the loop and the manual appending) and focus on the "what" (the logic).</p>
let</span> evenNumbers </span>=</span> numbers.</span>filter</span> {</span> $0</span> %</span> 2</span> ==</span> 0</span> }</span></span></code></pre>
Just as map</code> removes the logic, mutations, and iterations of how to create your new container, filter</code> does the same thing, removing the logic of how to filter and instead focusing on what to filter.</p>
Reduce: The Assembler#</span></a>
</h2>
reduce</code> is used to combine all the items in a collection into a single value. This could be a sum, a string concatenation, or even a new dictionary.</p>
The Imperative Way#</span></a>
</h3>
To sum an array, we usually create a variable at zero and add to it piece by piece.</p>
let</span> prices </span>=</span> [</span>10.0</span>, </span>20.0</span>, </span>30.0</span>]</span></span>
var</span> total:</span> Double</span> =</span> 0</span></span>
</span>
for</span> price </span>in</span> prices </span>{</span></span>
  total </span>+=</span> price</span></span>
}</span></span>
// total: 60.0</span></span></code></pre>The Functional Way#</span></a>
</h3>
reduce</code> takes two arguments: an initial value and a closure that defines how to combine the current running total with the next element.</p>
let</span> total </span>=</span> prices.</span>reduce</span>(</span>0</span>, </span>{</span> runningTotal, nextPrice </span>in</span></span>
  runningTotal </span>+</span> nextPrice</span></span>
})</span></span>
</span>
// Even shorter version using Swift's operator shorthand:</span></span>
let</span> total </span>=</span> prices.</span>reduce</span>(</span>0</span>, </span>+</span>)</span></span></code></pre>Composing the Trio: Map, Filter, and Reduce#</span></a>
</h2>
The real power of functional programming in Swift is composition. Because these functions return new collections, you can chain them together to perform complex data processing in a single, readable pipeline.</p>
The scenario: we have a list of orders. We want to find all orders over $50, apply a 10% tax to them, and then find the grand total.</p>
The All-in-One Pipeline#</span></a>
</h3>
struct</span> Order</span> {</span></span>
  let</span> id:</span> Int</span></span>
  let</span> amount:</span> Double</span></span>
}</span></span>
</span>
let</span> orders </span>=</span> [</span></span>
  Order</span>(</span>id</span>:</span> 1</span>, </span>amount</span>:</span> 20.0</span>)</span>,</span></span>
  Order</span>(</span>id</span>:</span> 2</span>, </span>amount</span>:</span> 60.0</span>)</span>,</span></span>
  Order</span>(</span>id</span>:</span> 3</span>, </span>amount</span>:</span> 100.0</span>)</span></span>
]</span></span>
</span>
let</span> grandTotal </span>=</span> orders</span></span>
  .</span>filter</span> {</span> $0.amount</span> ></span> 50</span> }</span> // Keep only expensive orders.</span></span>
  .</span>map</span> {</span> $0.amount</span> *</span> 1.10</span> }</span>  // Add 10% tax.</span></span>
  .</span>reduce</span>(</span>0</span>, </span>+</span>)</span>              // Sum them up.</span></span>
</span>
print</span>(</span>grandTotal</span>)</span> // 176.0</span></span></code></pre>
By chaining these functions together we have avoided creating multiple var</code>s along the way. For instance, there is no need for an ordersOver50</code> array. Or even an ordersWithTax</code> array. Or a totalValue</code> var to hold the accumulative total.</p>
At each point we just describe what it is we want from the data.</p>
Wait... Can this be a Filter or Reduce?#</span></a>
</h2>
We've all been there typing out yet another for</code> loop. But before you hit enter, take a second to look at the "shape" of the code you're about to write. Just like we learned to spot a map</code> by seeing a transformation, filter</code> and reduce</code> have their own distinct scents.</p>
The Filter Smell: The Selective Picker#</span></a>
</h3>
If you find yourself writing a loop that contains a single if</code> statement just to decide whether or not to append an item to a new array, you're writing a filter</code>.</p>
The sign: You have a bucket array, var results = []</code>, and a loop that says: "If this specific thing is true, put it in the bucket."</p>
The fix: Stop managing the bucket. Use .filter { ... }</code> and just provide the truth logic.</p>
The Reduce Smell: The Master Assembler#</span></a>
</h3>
If you see a standalone variable sitting right above a loop, like var total = 0</code> or var combinedString = ""</code>, and that variable gets updated every single time the loop ticks, you're looking at a reduce</code>.</p>
The sign: You are folding a whole list of items down into one single result. Whether you're summing prices, building a sentence, or even flattening nested data, if the list goes in and one single thing comes out, it's a reduce</code>.</p>
The fix: Ditch the mutable variable. Use .reduce(initialValue) { ... }</code> to assemble your result in one clean shot.</p>
Recognizing these patterns is like developing a superpower. Instead of reading how the computer is moving bits around, you start reading what your data is actually doing.</p>
Coming Up in Part 3: The Power of Reduce#</span></a>
</h2>
While we used reduce</code> here to sum numbers, it is secretly the most powerful function in the functional toolkit. In the next part, we will explore how reduce</code> can actually build other functions like map</code> and filter</code>, and how to use it for complex tasks like partitioning data into groups, such as grouping objects by month.</p>


Functional Thinking in Swift: Part 1 - Map
2025-12-16T00:00:00+00:00
Often, when people talk about Functional Programming (FP), it can become very abstract or academic, and the practical essence gets lost. This is especially true if it's not a paradigm you are used to; it requires a different way of thinking compared to the standard imperative approaches usually taught to beginners.</p>
Swift gives us small functional tools that we often use without realizing they are "functional." As Swift isn't a pure FP language, we aren't trying to rewrite our entire app using strict FP. We simply want to use the tools we are given to simplify our code.</p>
I'd like to build up a toolkit of these functional Swift tools so we can leverage some powerful, compositional thinking without getting lost in abstract definitions.</p>
Why functional thinking?#</span></a>
</h2>
Functional thinking isn't about writing "clever" code. It's about changing the way you think about code. Instead of focusing on steps and mutable state, you focus on data flowing through small, predictable transformations.</p>
This shift makes your intentions clearer, reduces hidden complexity, and leads to code that behaves the same way every time you run it. In other words: fewer surprises, fewer accidental edge cases, and a more deterministic system overall. Even the simplest functional tools, like map</code>, start training your brain to express what should happen rather than how to make it happen, and that mindset scales beautifully as your codebase grows.</p>
The Map function#</span></a>
</h2>
At its core, map</code> just means:</p>
Take a container of items. Transform the items. Return a new container of the transformed items.</p>
That's it.</p>
Let's look at a super small example first.</p>
The imperative version:</p>
let</span> numbers </span>=</span> [</span>1</span>, </span>2</span>, </span>3</span>]</span></span>
var</span> doubled:</span> [</span>Int</span>]</span> =</span> []</span></span>
</span>
for</span> i </span>in</span> numbers </span>{</span></span>
  doubled.</span>append</span>(</span>i </span>*</span> 2</span>)</span></span>
}</span></span>
// doubled = [2, 4, 6]</span></span></code></pre>
The functional equivalent using map</code>:</p>
let</span> doubled </span>=</span> [</span>1</span>, </span>2</span>, </span>3</span>].</span>map</span> {</span> $0</span> *</span> 2</span> }</span></span>
// doubled = [2, 4, 6]</span></span></code></pre>
Here, we have taken a container, Array</code>, of items, Int</code>, and transformed them by doubling their value into a new container, Array</code>, of items, Int</code>.</p>
Rather than describing the steps to get there, we have described what we want the output to be: "An array where each value is double the value of the source array."</p>
Why does this matter?#</span></a>
</h2>
map</code> has done a few really nice things for us here:</p>

Declarative Style: We describe what we want rather than how to create it. No counters, no appending, and no manual iteration.</li>
Immutability: There is no mutation of values. Since many Swift containers are value types (copy-on-write), avoiding mutation gives us better clarity, thread safety, and predictability.</li>
Clearer Intent: "Transform these values" is much easier to read at a glance than "iterate over these values and accumulate them into a new variable."</li>
Safety: We don't have to worry about what to do if the container is empty. map</code> handles empty containers gracefully.</li>
</ul>
It works across many types#</span></a>
</h2>
The definition of map</code> doesn't talk about Array</code>; it talks about "containers," and there are many different types of containers in Swift. All of them are mappable.</p>
In every case, the function does the same thing: transform the contents of the container and return a new container with the new contents.</p>
Optional#</span></a>
</h3>
Because Optional</code> is a container, it contains either some value or none, we can map it. We get back another Optional</code> of the transformed type.</p>
let</span> title:</span> String</span>? =</span> "Hello, World!"</span></span>
let</span> titleLength </span>=</span> title.</span>map</span> {</span> $0.count</span> }</span></span>
// titleLength is Int? (13)</span></span>
</span>
let</span> name:</span> String</span>? =</span> nil</span></span>
let</span> nameLength </span>=</span> name.</span>map</span>(</span>\.count</span>)</span></span>
// nameLength is nil</span></span></code></pre>
Here, map</code> transforms the contents without changing the type of the container. If the value is nil</code>, we simply get nil</code> back. This saves a lot of if let</code> unwrapping and safety checking.</p>
Result#</span></a>
</h3>
Result</code> is also a container. It contains either a .success</code> value or a .failure</code> error. map</code> will transform the Success</code> value if it exists, leaving the Failure</code> case untouched.</p>
let</span> result: Result</span><</span>User, </span>any</span> Error</span>></span> =</span> .</span>success</span>(</span>userData</span>)</span></span>
let</span> userName </span>=</span> result.</span>map</span> {</span> $0.name</span> }</span></span>
// userName is Result<String, any Error> with the .success case.</span></span>
</span>
let</span> result: Result</span><</span>User, </span>any</span> Error</span>></span> =</span> .</span>failure</span>(</span>error</span>)</span></span>
let</span> userAge </span>=</span> result.</span>map</span>(</span>\.age</span>)</span></span>
// userAge is Result<Int, any Error> with the .failure(error) case.</span></span></code></pre>A real-world example#</span></a>
</h2>
As a more "real" example, let's imagine a network call to a weather API that we want to call and then map into our view models.</p>
struct</span> WeatherCityDTO</span>:</span> Decodable</span> {</span></span>
  let</span> id: UUID</span></span>
  let</span> city:</span> String</span></span>
  let</span> humidity:</span> Double</span>?</span></span>
  let</span> temperatureCelsius:</span> Double</span></span>
}</span></span>
</span>
struct</span> CityViewModel</span> {</span></span>
  let</span> name:</span> String</span></span>
  let</span> humidityTitle:</span> String</span>?</span></span>
  let</span> tempTitle:</span> String</span></span>
}</span></span>
</span>
func</span> fetchCityWeather</span>()</span> async throws</span> -></span> [</span>CityViewModel</span>] {</span></span>
  try await</span> networkClient.</span>fetchCities</span>()</span></span>
    .</span>map</span> {</span> cityDTO </span>in</span></span>
      CityViewModel</span>(</span></span>
        name</span>:</span> cityDTO.city,</span></span>
        // Using map on the Optional property inside the Array map.</span></span>
        humidityTitle</span>:</span> cityDTO.humidity.</span>map</span> {</span> humidityDescription</span>(</span>from</span>:</span> $0</span>) }</span>,</span></span>
        tempTitle</span>:</span> "</span>\(</span>cityDTO.temperatureCelsius.</span>rounded</span>())</span>°C"</span></span>
      )</span></span>
    }</span></span>
}</span></span></code></pre>
We've used map</code> to take an array of WeatherCityDTO</code> from a network call and transformed it into an array of our own view models. We also used map</code> to optionally create a humidityTitle</code> if the humidity exists in the DTO.</p>
All without mutating an array or creating a single for</code> loop.</p>
The Trap: When Map Isn't Enough#</span></a>
</h2>
map</code> is fantastic when you have a 1-to-1 transformation. You put one thing in, you get one transformed thing out.</p>
But what happens if your transformation also returns a container?</p>
Imagine you have an array of String</code> identifiers, and you want to turn them into URLs:</p>
let</span> strings </span>=</span> [</span>"https://www.apple.com"</span>, </span>"broken-link"</span>]</span></span>
let</span> urls </span>=</span> strings.</span>map</span> {</span> URL</span>(</span>string</span>:</span> $0</span>) }</span></span>
// Result: [Optional<URL>, Optional<URL>]</span></span></code></pre>
Because URL(string:)</code> returns an optional, map</code> wraps that optional inside the array. You end up with an array of optionals, [URL?]</code>, which is usually annoying to work with. You technically have a container inside a container.</p>
Or, what if you want to map over a list of user IDs and fetch their recent posts?</p>
let</span> userIDs </span>=</span> [</span>1</span>, </span>2</span>, </span>3</span>]</span></span>
let</span> posts </span>=</span> userIDs.</span>map</span> {</span> fetchPosts</span>(</span>for</span>:</span> $0</span>) }</span></span>
// Result: [[Post], [Post], [Post]]</span></span></code></pre>
You end up with an array of arrays.</p>
This is where map</code> hits its limit. When the shape of your data starts getting nested, optionals inside arrays, or arrays inside arrays, map</code> can't flatten that structure for you.</p>
Next time#</span></a>
</h2>
This limitation is exactly where our next set of tools comes in. In the next part, we will look at compactMap</code> and flatMap</code> to see how we can handle these nested containers gracefully.</p>
We will also look at filter</code> and reduce</code>, and eventually, how to compose all these simple tools together to perform powerful data transformations with readable, declarative code.</p>