Swift Higher-Order Functions: map, filter, reduce, flatMap in Real Projects

Code 1: map — Transform Every Element

When to use: You need to convert every element in an array to something else. The count stays the same; the type can change.

// THE OLD WAY: for loop with manual array building
let names = ["Alice", "Bob", "Charlie"]
var uppercasedNames: [String] = []
for name in names {
    uppercasedNames.append(name.uppercased())
}
print(uppercasedNames)  // ["ALICE", "BOB", "CHARLIE"]

// THE MAP WAY: one line, same result, no mutable variable
let uppercased = names.map { $0.uppercased() }
print(uppercased)  // ["ALICE", "BOB", "CHARLIE"]

// Real-world: Converting API DTOs into ViewModels
struct UserDTO: Decodable {
    let id: Int
    let full_name: String
    let email_address: String
    let avatar_url: String?
}

struct UserViewModel: Identifiable {
    let id: Int
    let displayName: String
    let email: String
    let avatarURL: URL?

    init(dto: UserDTO) {
        self.id = dto.id
        self.displayName = dto.full_name
        self.email = dto.email_address
        self.avatarURL = URL(string: dto.avatar_url ?? "")
    }
}

let dtos: [UserDTO] = try JSONDecoder().decode([UserDTO].self, from: jsonData)
let viewModels = dtos.map { UserViewModel(dto: $0) }
// Clean, type-safe, no for loop needed.

The subtle detail most people miss: map is lazy if you call it on a LazySequence. Writing dtos.lazy.map { ... } won’t execute the transformation immediately — it waits until you actually access the result. This can save significant work when dealing with large arrays.

Code 2: filter — Pick the Ones You Want

When to use: You need to remove elements that don’t meet a condition.

// THE OLD WAY: for loop + append
let orders: [Order] = ...
var completedOrders: [Order] = []
for order in orders {
    if order.status == .completed {
        completedOrders.append(order)
    }
}

// THE FILTER WAY
let completed = orders.filter { $0.status == .completed }

// Real-world: filtering a message list for the current user
let myMessages = messages.filter {
    $0.recipientId == currentUserId && !$0.isRead
}

// Optimization: combine conditions into ONE filter call
// BAD: two passes, two intermediate arrays
let activeAdmins = users.filter { $0.isActive }.filter { $0.role == .admin }

// GOOD: one pass, one array
let activeAdmins = users.filter { $0.isActive && $0.role == .admin }

// filter doesn't modify the original — it returns a new array
print(orders.count)      // original unchanged
print(completed.count)   // filtered copy

Code 3: reduce — Combine Everything into One

When to use: You need to accumulate all elements into a single result — summing, concatenating, building dictionaries.

// Basic: summing prices
let prices = [9.99, 24.50, 15.00, 3.99]
let total = prices.reduce(0) { result, price in result + price }
print(total)  // 53.48

// More concise with +=
let total = prices.reduce(0, +)

// Real-world: joining IDs into a query string
let selectedIds = [101, 202, 303]
let queryString = selectedIds
    .map(String.init)
    .joined(separator: ",")
print(queryString)  // "101,202,303"

// reduce(into:) — the MUTATING version, much faster for large arrays
// SLOW: creates a new dictionary on every iteration
let categoryCounts = orders.reduce([String: Int]()) { result, order in
    var dict = result  // copy happens every iteration!
    dict[order.category, default: 0] += 1
    return dict
}

// FAST: modifies the same dictionary in place
let categoryCounts = orders.reduce(into: [String: Int]()) { dict, order in
    dict[order.category, default: 0] += 1
}
print(categoryCounts)  // ["Electronics": 5, "Books": 3, "Clothing": 8]

// Real-world: grouping items by a property
let grouped = orders.reduce(into: [String: [Order]]()) { dict, order in
    dict[order.status.rawValue, default: []].append(order)
}
// ["pending": [...], "completed": [...], "cancelled": [...]]
// I use reduce(into:) whenever I'm processing more than a few hundred items.
// The difference is noticeable — on 10K items it's 3-5x faster.

Code 4: flatMap — Flatten Nested Arrays

// Nested arrays: [[1, 2], [3, 4], [5]] → [1, 2, 3, 4, 5]
let nested = [[1, 2], [3, 4], [5]]
let flat = nested.flatMap { $0 }
print(flat)  // [1, 2, 3, 4, 5]

// Real-world: merging multiple API batches
let batch1 = [Product(id: 1, name: "Laptop")]
let batch2 = [Product(id: 2, name: "Phone")]
let batch3 = [Product(id: 3, name: "Tablet")]

let allProducts: [Product] = [batch1, batch2, batch3].flatMap { $0 }
print(allProducts.count)  // 3

// Nested model: User with multiple orders
struct User {
    let name: String
    let orders: [Order]
}

let users: [User] = ...
let allOrders = users.flatMap { $0.orders }
// Extracts all orders from all users into a single flat array

Code 5: compactMap — Filter Out Nils

// compactMap: transforms AND removes nils in one step
let strings = ["1", "2", "three", "4", "five"]
let numbers = strings.compactMap { Int($0) }
print(numbers)  // [1, 2, 4] — "three" and "five" silently dropped

// WITHOUT compactMap: manual unwrapping + filtering
var numbers: [Int] = []
for s in strings {
    if let n = Int(s) {
        numbers.append(n)
    }
}

// Real-world: extracting a field from dictionary responses
let apiResponses: [[String: Any]] = [
    ["name": "Alice", "age": 30],
    ["name": "Bob"],                    // no "age" key
    ["name": "Charlie", "age": 25],
]

let ages = apiResponses.compactMap { $0["age"] as? Int }
print(ages)  // [30, 25] — Bob's missing age is safely skipped

// Real-world: converting strings to URLs (some might be invalid)
let urlStrings = [
    "https://example.com",
    "not a url",
    "https://apple.com",
    ""
]
let validURLs = urlStrings.compactMap { URL(string: $0) }
print(validURLs.count)  // 2 — only valid URLs

// The rule: "Array inside array? flatMap. Optionals I want to drop? compactMap."

Code 6: Real-World Chain — JSON Processing Pipeline

This example is from an e-commerce project I worked on last year. The task: parse JSON, filter active products, transform into view models, and sort — all in one readable chain:

// Raw JSON from the API
let jsonString = """
[
    {"id": 1, "name": "Laptop", "price": 999.99, "in_stock": true, "tags": ["electronics", "computers"]},
    {"id": 2, "name": "Old Phone", "price": 199.99, "in_stock": false, "tags": ["electronics"]},
    {"id": 3, "name": "Desk Chair", "price": 299.99, "in_stock": true, "tags": ["furniture"]},
    {"id": 4, "name": "Headphones", "price": 89.99, "in_stock": true, "tags": ["electronics", "audio"]}
]
"""
let jsonData = jsonString.data(using: .utf8)!

// Step 1: Decode
struct ProductDTO: Decodable {
    let id: Int
    let name: String
    let price: Double
    let in_stock: Bool
    let tags: [String]
}

// Step 2: The chain — decode, filter, transform, sort
let viewModels = try JSONDecoder().decode([ProductDTO].self, from: jsonData)
    .filter { $0.in_stock }                              // only in-stock
    .map { ProductViewModel(                              // transform
        id: $0.id,
        title: $0.name,
        priceText: String(format: "$%.2f", $0.price),
        tagCount: $0.tags.count
    )}
    .sorted { $0.priceText < $1.priceText }              // sort by price

// Each step does ONE thing. The chain reads like English:
// "Decode products, filter in-stock ones, map to view models, sort by price."

// For VERY large arrays (10K+ items), add .lazy to avoid intermediate arrays:
let viewModels = try JSONDecoder().decode([ProductDTO].self, from: jsonData)
    .lazy                                          // only traverse once
    .filter { $0.in_stock }
    .map { ProductViewModel(...) }
    .sorted { $0.priceText < $1.priceText }
// .lazy chains everything into a single pass — significant speedup.

Why the chain wins: readability (each step’s purpose is explicit), maintainability (change a condition? just edit the filter line), and safety (no mutable intermediate variables, less room for state bugs). But beware the performance trap — chaining traverses the array multiple times. For very large arrays, use .lazy to combine everything into a single pass.

My Experience: Why I Stopped Using for Loops

Early in my career, I wrote a feature that processed user orders — filter by status, sum totals, group by category. It was 40 lines of nested for loops with three mutable arrays. A code review flagged it, and I rewrote it using filter, reduce(into:), and grouped(by:). The result was 8 lines. But the real win wasn’t fewer lines — in the next two months, that module had zero bugs. The old for-loop version had 3 bugs in its first sprint alone (off-by-one in the index, a missing break, and a mutated array being read during iteration). Higher-order functions eliminate those failure modes because there are no indices, no breaks, and no mutation.

Since then, I’ve adopted a rule: if a for loop is more than 5 lines, I stop and look for a map/filter/reduce combination. Not because it’s “cooler” — because it’s safer. The compiler checks the logic for you. With for loops, you’re on your own.

Summary

map — transform every element, same count. filter — keep matching elements, fewer items. reduce — combine into one result. flatMap — flatten nested arrays. compactMap — transform and drop nils.

Don’t use higher-order functions just to look clever. If it feels awkward, stick with for loops. But if your for loop is more than 5 lines, there’s probably a map + filter combination that does the same thing more clearly. Higher-order functions let you tell the compiler what you want, not how to do it. Less code, fewer places for bugs to hide. That’s the real win.