{"id":"l-sw-1-4","courseId":"swift-essentials","lang":"en","kind":"lesson","summary":"Write functions with clear argument labels and default values, then replace hand-written loops with closures passed to filter, map, reduce and sorted.","html":"

The for loops from the last lesson work, but they make you read five lines to learn one fact, such as “the total spent on food”. Functions give a piece of logic a name. Closures let you hand a small piece of logic to someone else, like “keep the ones over 50”, and Swift’s collection methods are built around them. Together they turn most loops in Pocket Budget into one readable line.

\n

For the examples, here is a minimal expense type. You’ll learn what struct really means in the next section; for now, read it as “a value with a title, an amount and a category”.

\n
Expense.swift
import Foundation\n\nstruct Expense {\n    let title: String\n    let amount: Decimal\n    let category: String\n}\n\nlet expenses = [\n    Expense(title: \"Groceries\", amount: 64.2, category: \"Food\"),\n    Expense(title: \"Bus pass\", amount: 45, category: \"Transport\"),\n    Expense(title: \"Coffee\", amount: 4.5, category: \"Food\"),\n    Expense(title: \"Concert\", amount: 80, category: \"Fun\"),\n]
\n

Functions that read like sentences

\n
Swift
func total(of expenses: [Expense], in category: String? = nil) -> Decimal {\n    var sum: Decimal = 0\n    for expense in expenses where category == nil || expense.category == category {\n        sum += expense.amount\n    }\n    return sum\n}\n\ntotal(of: expenses)                  // 193.7\ntotal(of: expenses, in: \"Food\")      // 68.7
\n

Each parameter has two names. The argument label (of, in) is what callers write; the parameter name (expenses, category) is what the body uses. That split is why Swift call sites read like English: “total of expenses in Food”. The = nil gives category a default value, so callers can leave it out. Write _ as the label when it adds nothing, as in print(_:).

\n

The -> Decimal declares the return type. A function that returns nothing omits the arrow.

\n

Closures: functions without names

\n

A closure is a block of code you can store in a constant or pass as an argument. Here is a closure that decides whether an expense is large:

\n
Swift
let isLarge: (Expense) -> Bool = { expense in\n    expense.amount > 50\n}\nisLarge(expenses[0])     // true
\n

The type (Expense) -> Bool reads “takes an Expense, returns a Bool”. Parameters go before in, the body after it. A single-expression body returns its value without writing return.

\n

Now pass logic like that to filter. These three lines are the same call, progressively shortened:

\n
Swift
let large1 = expenses.filter({ (expense: Expense) -> Bool in\n    return expense.amount > 50\n})\nlet large2 = expenses.filter { expense in expense.amount > 50 }\nlet large3 = expenses.filter { $0.amount > 50 }
\n

When a closure is the last argument, you can write it after the parentheses (trailing closure syntax) and drop empty parentheses entirely. Swift already knows the types from filter’s signature, so you can drop those too. $0 is the first parameter, $1 the second.

\n\n

filter, map, reduce, sorted

\n

These four cover most of what you do with collections:

\n
Swift
let food = expenses.filter { $0.category == \"Food\" }        // keep matching expenses\nlet titles = food.map { $0.title }                           // [\"Groceries\", \"Coffee\"]\nlet foodTotal = food.reduce(0) { $0 + $1.amount }            // 68.7\nlet biggestFirst = expenses.sorted { $0.amount > $1.amount } // Concert, Groceries, ...
\n

reduce starts from an initial value (0) and folds each element into a running result: $0 is the total so far and $1 is the next expense. sorted(by:) asks your closure “should $0 come before $1?”.

\n

Chain them, and the pipeline reads in the order it runs:

\n
Swift
let foodSpend = expenses\n    .filter { $0.category == \"Food\" }\n    .map(\\.amount)\n    .reduce(0, +)
\n

\\.amount is a key path, a shorthand for { $0.amount }, and + is itself a function that takes two values and returns their sum, so you can pass it straight to reduce.

\n
\n Four expenses flow into filter, which keeps the two food expenses; map turns them into two amounts; reduce adds them into one total of 68.7.\n \n 4 expenses\n [Expense]\n \n \n filter\n 2 food items\n \n \n map(\\.amount)\n [64.2, 4.5]\n \n \n reduce\n 68.7\n Each step returns a new value; the original array never changes\n
filter, map and reduce as a pipeline
\n\n

Closures capture their surroundings

\n

A closure can use variables from the scope where it was created, and it keeps them alive:

\n
Swift
func makeLimitCheck(limit: Decimal) -> (Decimal) -> Bool {\n    return { amount in amount > limit }\n}\n\nlet overFoodLimit = makeLimitCheck(limit: 60)\noverFoodLimit(64.2)     // true
\n

makeLimitCheck has returned, yet the closure still knows limit is 60. When a function stores a closure parameter to call later, instead of calling it before returning, Swift makes you mark that parameter @escaping. The keyword is a warning label for readers: this closure outlives the call, so whatever it captures stays alive too.

\n

This capturing is what lets SwiftUI buttons run code that refers to your view’s data long after the view was built. It has one sharp edge, a reference cycle when a class and a closure capture each other, which you’ll meet with classes in the next lesson.

\n

You can now name logic, pass it around and replace loops with pipelines. That finishes the core language. The next section is about modelling: deciding whether Pocket Budget’s data should be structs, classes or enums, and why that choice changes how your app behaves.

\n","toc":[{"id":"sec-1","text":"Functions that read like sentences","level":2},{"id":"sec-2","text":"Closures: functions without names","level":2},{"id":"sec-3","text":"filter, map, reduce, sorted","level":2},{"id":"sec-4","text":"Closures capture their surroundings","level":2}],"takeaways":["Argument labels make call sites read like sentences; use _ only when the label would add nothing.","A closure is a function without a name, and trailing closure syntax lets you write it after the call’s parentheses.","filter keeps elements, map transforms them, reduce combines them into one value, and sorted(by:) returns a new ordered array.","A closure captures the variables it uses, so it can carry context such as a limit to wherever it’s called later."],"further":[{"title":"Functions","url":"https://docs.swift.org/swift-book/documentation/the-swift-programming-language/functions/"},{"title":"Closures","url":"https://docs.swift.org/swift-book/documentation/the-swift-programming-language/closures/"}],"quiz":[{"q":"

Given func total(of expenses: [Expense], in category: String? = nil) -> Decimal, which call compiles?

","options":[{"text":"total(expenses, "Food")","why":"Both parameters have argument labels, so the call must use them."},{"text":"total(expenses: expenses)","why":"expenses is the parameter name used inside the function. Callers use the label of."},{"text":"total(of: expenses)","why":"Correct. The second parameter has a default value, so you can leave it out."}],"answer":2},{"q":"

What does [3, 8, 12].map { $0 * 2 }.filter { $0 > 10 } produce?

","options":[{"text":"[16, 24]","why":"Correct. map doubles every number to [6, 16, 24], then filter keeps those above 10."},{"text":"[24]","why":"That would be filtering before mapping (12 is the only value above 10). The chain runs left to right."},{"text":"[6, 16, 24]","why":"That’s the result after map only; filter still has to remove 6."},{"text":"40","why":"A single combined value is what reduce produces. map and filter both return arrays."}],"answer":0},{"q":"

You write expenses.sorted { $0.amount > $1.amount } on its own line and nothing changes. Why?

","options":[{"text":"The closure compares the wrong way round.","why":"The comparison is fine (largest first). The result is the problem."},{"text":"sorted returns a new array, and the code throws that result away.","why":"Correct. Assign it (let biggestFirst = …) or call sort on a var to sort in place. Xcode warns about the unused result."},{"text":"Closures can’t read properties like amount.","why":"Closures can read anything in scope, including properties of their parameters."}],"answer":1},{"q":"

let check = makeLimitCheck(limit: 60) returns a closure { amount in amount > limit }. What does check(64) return, long after makeLimitCheck finished?

","options":[{"text":"It doesn’t compile, because limit no longer exists.","why":"The closure captured limit, so it lives as long as the closure does."},{"text":"false, because captured values reset to zero.","why":"Captures keep their values; nothing resets."},{"text":"true","why":"Correct. The closure captured limit as 60, and 64 is greater than 60."}],"answer":2}],"exercise":{"kind":"fill","language":"swift","template":"// expenses: [Expense], each with title, amount and category\nlet large = expenses.{{0}} { $0.amount > 50 }\nlet titles = large.{{1}} { $0.title }\nlet spent = expenses.{{2}}(0) { $0 + $1.amount }\nlet biggestFirst = expenses.sorted { $0.amount {{3}} $1.amount }","blanks":[{"answers":["filter"]},{"answers":["map"]},{"answers":["reduce"]},{"answers":[">"]}],"title":"Replace the loops with closures","prompt":"

Pocket Budget’s summary screen needs four values. Fill each blank so that large holds the expenses over 50, titles holds their titles, spent is the total of all amounts, and biggestFirst lists every expense from the largest amount to the smallest.

\n","hints":["Each of the first three blanks is the name of a collection method from this lesson.","reduce takes a starting value and a closure that combines the running total ($0) with the next element ($1).","sorted(by:) asks “should $0 come before $1?”. For largest first, the answer is yes when $0 is bigger."],"explanation":"

filter keeps elements for which the closure returns true, map turns each expense into its title, and reduce(0) folds every amount into one total. sorted puts $0 first whenever the closure returns true, so $0.amount > $1.amount gives descending order; < would put the cheapest first.

\n
Swift
let large = expenses.filter { $0.amount > 50 }\nlet titles = large.map { $0.title }\nlet spent = expenses.reduce(0) { $0 + $1.amount }\nlet biggestFirst = expenses.sorted { $0.amount > $1.amount }
\n","checkLabels":{}},"words":679,"readMinutes":3}