Functions, Parameters, and Closures

Introduction

Functions are the principal unit of reusable behavior in Swift. They allow a developer to name an operation, define the data it requires, and specify the result it produces. In an iOS application, functions appear everywhere: validating form input, converting model data, responding to user actions, loading records, formatting dates, and coordinating asynchronous work.

Well-designed functions improve readability, testing, maintenance, and collaboration. Swift strengthens function design through argument labels, type inference, default and variadic parameters, value-returning functions, inout parameters, nested functions, function types, closures, capture behavior, and higher-order functions. These features support both object-oriented and functional programming styles.

This chapter develops these ideas from basic syntax to practical application. The emphasis is not merely on writing code that compiles, but on designing interfaces that communicate intent and reduce avoidable errors.

Learning Objectives

By the end of this chapter, you should be able to:

• define and call Swift functions;
• use parameter names, argument labels, default values, and variadic parameters appropriately;
• return values and multiple results safely;
• explain the behavior and limitations of inout parameters;
• write nested functions and functions that return other functions;
• describe function types and assign functions to variables;
• create closures with explicit and inferred syntax;
• explain closure capture and escaping behavior;
• apply higher-order functions such as map, filter, and reduce;
• select appropriate designs for readable, testable iOS code.

1. The Function as a Contract

A function is a named, reusable block of code. Its declaration specifies a contract: the inputs it accepts, the work it performs, and the output it may return.

func greet(name: String) -> String {
    return "Hello, \(name)!"
}

let message = greet(name: "Maya")

The function name is greet, the parameter is name of type String, and the return type is also String. The arrow -> separates the parameter list from the return type. Swift infers the type of message from the function result.

A function that produces no useful result may omit the return type:

func logStartup() {
    print("Application started")
}

Swift treats this as returning Void, which is an alias for the empty tuple type (). A return statement may be omitted when execution reaches the end of a Void function.

A function should generally have one clear responsibility. For example, a function named validateEmail should validate an email address, not also save a user and display an alert. Focused functions are easier to understand and unit-test.

Early return and guard

The guard statement is useful when a function cannot continue unless a condition is satisfied:

func display(username: String?) {
    guard let username else {
        print("No username supplied")
        return
    }

    print("User: \(username)")
}

A guard condition must transfer control out of the current scope when it fails. This keeps the main path of a function less deeply nested.

2. Parameters and Argument Labels

Swift distinguishes between a parameter name used inside a function and an argument label used when calling it. By default, the first name is the argument label and the second is the local parameter name:

func send(message: String, to recipient: String) {
    print("Sending \(message) to \(recipient)")
}

send(message: "Welcome", to: "Aisha")

Here, message and to are argument labels, while message and recipient are the names available inside the function.

Argument labels make calls read like natural language and clarify the role of values. They are especially important when several parameters have the same type.

func move(from start: Int, to end: Int) { }
move(from: 2, to: 8)

To suppress an argument label, use an underscore:

func square(_ value: Double) -> Double {
    value * value
}

let result = square(4.0)

The underscore is appropriate when the call is already clear, but it should not be used automatically. A label such as for, named, or using can prevent misuse.

External labels and API clarity

Consider these two calls:

configure(theme: "Dark", fontSize: 18)
configure("Dark", 18)

The first communicates the meaning of each argument. In production code, labels are part of the function's usability and should be designed as carefully as the implementation.

3. Default and Variadic Parameters

A default parameter value allows callers to omit an argument when a sensible standard exists.

func connect(timeout: Double = 30.0) {
    print("Timeout: \(timeout) seconds")
}

connect()
connect(timeout: 10.0)

Default values reduce repetitive calls, but they should be used only when the default is safe and unsurprising. A default timeout may be reasonable; a default account identifier usually is not.

A variadic parameter accepts zero or more values of the same type. Inside the function, it behaves like an array.

func average(_ values: Double...) -> Double? {
    guard !values.isEmpty else { return nil }
    let total = values.reduce(0, +)
    return total / Double(values.count)
}

let result = average(4.0, 6.0, 10.0)

The return type is optional because the average of no values is undefined in this design. The calculation is valid when at least one value is supplied. Variadic parameters must be the final parameter in a function declaration.

A variadic parameter is convenient for a small number of directly supplied values. If a caller already has an array, passing that array directly is not equivalent to expanding it into separate arguments; in such cases, accept an array parameter instead.

4. Return Values and Multiple Results

A return value communicates the result of an operation. The return type should express meaningful states rather than hiding them.

func percentage(completed: Int, total: Int) -> Double? {
    guard total > 0, completed >= 0, completed <= total else {
        return nil
    }
    return Double(completed) / Double(total) * 100.0
}

The result is optional because invalid input has no meaningful percentage in this interface. The conversion to Double is important: integer division would discard the fractional component.

Swift functions can return tuples, which are useful for small, closely related results:

func minMax(_ values: [Int]) -> (minimum: Int, maximum: Int)? {
    guard let first = values.first else { return nil }
    var minimum = first
    var maximum = first

    for value in values.dropFirst() {
        minimum = min(minimum, value)
        maximum = max(maximum, value)
    }
    return (minimum, maximum)
}

if let result = minMax([8, 3, 12, 5]) {
    print(result.minimum)
    print(result.maximum)
}

For larger or public interfaces, a named structure is often clearer than a tuple because it provides a stable type that can later gain documentation and behavior.

Throwing functions

When failure requires more explanation than nil can provide, a function can throw an error:

enum PasswordError: Error {
    case tooShort
}

func validate(password: String) throws {
    guard password.count >= 8 else {
        throw PasswordError.tooShort
    }
}

The caller must handle the possibility of failure using try, do-catch, or another appropriate mechanism. A throwing function is not the same as a function returning an optional: an optional says that a result may be absent, while an error can describe why an operation failed.

5. inout Parameters

Swift normally passes values to functions without allowing the function to replace the caller's variable. An inout parameter permits a function to modify the original variable:

func swapValues(_ a: inout Int, _ b: inout Int) {
    let temporary = a
    a = b
    b = temporary
}

var first = 3
var second = 7
swapValues(&first, &second)

The ampersand at the call site documents that the function may modify the argument. The argument must be a variable, not a literal or constant.

inout is useful for small, local mutations, but it should not be the default design. It can make data flow less obvious and introduces exclusivity requirements: Swift must prevent overlapping access to the same storage. For example, attempting to pass the same variable to two simultaneous inout parameters can produce a compiler error.

Prefer returning a new value when that makes the function easier to reason about:

func incremented(_ value: Int) -> Int {
    value + 1
}

This style makes the input-output relationship explicit and usually improves testability. Use inout when mutation is central to the operation and the resulting API is genuinely clearer.

6. Nested Functions and Function Types

A function may be defined inside another function. Such a nested function is scoped locally and can access values in its enclosing function.

func makeCounter(startingAt start: Int) -> () -> Int {
    var count = start

    func next() -> Int {
        count += 1
        return count
    }

    return next
}

let counter = makeCounter(startingAt: 10)
print(counter()) // 11
print(counter()) // 12

The nested function next captures count. Although makeCounter has finished, the returned function retains the captured state. This is a simple example of a closure and demonstrates why closures can model stateful behavior.

A function type describes the input and output of a function. The type (Int, Int) -> Int means a function accepting two Int values and returning an Int.

func add(_ x: Int, _ y: Int) -> Int {
    x + y
}

let operation: (Int, Int) -> Int = add
let sum = operation(4, 5)

Argument labels are not part of the function type. The function type records parameter and return types, not the labels used at a call site.

Functions can be passed as arguments and returned as results:

func apply(_ value: Int, using operation: (Int) -> Int) -> Int {
    operation(value)
}

func double(_ value: Int) -> Int {
    value * 2
}

let doubled = apply(6, using: double)

This ability is the foundation of higher-order programming.

7. Closures

A closure is an unnamed block of executable code that can be stored, passed, and returned. The most explicit closure syntax is:

let multiply: (Int, Int) -> Int = { (a: Int, b: Int) -> Int in
    return a * b
}

Swift can infer much of this information from the context:

let multiply: (Int, Int) -> Int = { a, b in
    a * b
}

Closures are commonly used for callbacks, sorting, collection transformation, and asynchronous completion handlers.

Trailing closure syntax

When a closure is the final argument, it can be written after the closing parenthesis:

let numbers = [1, 2, 3, 4]
let squares = numbers.map { number in
    number * number
}

If a function has only one closure argument, the parentheses can often be omitted:

numbers.forEach { print($0) }

The shorthand argument $0 refers to the first closure parameter, $1 to the second, and so forth. Shorthand syntax is concise, but explicit names are preferable when they improve comprehension.

Autoclosures

An @autoclosure delays evaluation of an expression until the closure is used. It is a specialized feature, often used by assertion-like APIs. It should not be used merely to make ordinary code look shorter because delayed evaluation can surprise readers.

8. Capturing Values and Reference Semantics

A closure can capture constants and variables from its surrounding context:

func makeGreeting(name: String) -> () -> String {
    return {
        "Hello, \(name)"
    }
}

let greeting = makeGreeting(name: "Noah")
print(greeting())

The returned closure retains access to name. Capturing a value does not necessarily mean that the closure receives a frozen snapshot. Captured variables may have storage that persists and can change:

func makeAccumulator() -> (Int) -> Int {
    var total = 0
    return { value in
        total += value
        return total
    }
}

let accumulator = makeAccumulator()
print(accumulator(3)) // 3
print(accumulator(4)) // 7

Closures can also capture reference types. In iOS development, this matters because a closure stored by an object can create a retain cycle. For example, an object retaining a closure that strongly captures the same object may prevent deallocation.

A capture list controls how values are captured:

class ScreenController {
    var title = "Home"

    func configure() {
        let action = { [weak self] in
            guard let self else { return }
            print(self.title)
        }
        action()
    }
}

weak captures an optional reference and does not keep the object alive. unowned captures a non-optional reference but assumes the referenced object will remain alive; using it after deallocation causes a runtime failure. unowned should therefore be used only when the lifetime relationship is guaranteed.

Capture lists can also capture values explicitly:

var color = "Blue"
let showColor = { [color] in
    print(color)
}
color = "Red"
showColor() // Blue

The closure captures the value of color at creation time in this example.

9. Escaping Closures

A closure parameter is non-escaping by default. This means the function must invoke it before the function returns. A closure is escaping when it is stored for later execution or used after the function returns.

var completionHandlers: [() -> Void] = []

func register(completion: @escaping () -> Void) {
    completionHandlers.append(completion)
}

The @escaping annotation tells Swift that the closure may outlive the function call. Escaping closures are common in networking, timers, notifications, and asynchronous APIs.

Escaping closures require careful ownership design. If an asynchronous operation retains a closure, and the closure strongly retains its owner, a retain cycle may result. Capture lists and explicit cancellation policies help manage this risk.

Modern Swift concurrency often uses async and await instead of completion-handler closures for asynchronous workflows. Closures remain important for callbacks, collection operations, event handlers, and APIs that have not adopted structured concurrency. The underlying design principle is unchanged: make lifetime, ownership, and failure behavior clear.

10. Higher-Order Functions

A higher-order function accepts a function or closure as an argument, returns one, or does both. Swift's collection methods provide practical examples.

map

map transforms every element and returns a new collection of transformed values:

let prices = [10.0, 20.0, 15.0]
let withTax = prices.map { price in
    price * 1.20
}

The closure must produce one output for each input. The result has the same number of elements as the source collection.

filter

filter keeps elements for which the closure returns true:

let scores = [45, 72, 88, 51]
let passing = scores.filter { $0 >= 50 }

The result may contain fewer elements, including none or all of the original elements.

reduce

reduce combines elements into one accumulated result:

let total = [4, 6, 10].reduce(0) { partial, value in
    partial + value
}

The first argument, 0, is the initial result. The closure receives the current accumulated value and the next element. The accumulator's type can differ from the element type, enabling transformations such as building dictionaries or strings.

compactMap and sorted

compactMap transforms elements while removing nil results:

let input = ["12", "x", "7"]
let numbers = input.compactMap { Int($0) }

sorted(by:) accepts a comparison closure:

let names = ["Zara", "Ari", "Mina"]
let ordered = names.sorted { first, second in
    first < second
}

The comparison closure should define a consistent ordering. Inconsistent comparisons can produce unpredictable results.

Applied Case: Filtering and Presenting Tasks

Background

Consider an illustrative iOS task application. Each task has a title, a completion state, and a priority. A view model must present incomplete high-priority tasks first, without changing the original data.

struct Task {
    let title: String
    let isComplete: Bool
    let priority: Int
}

Problem

A straightforward implementation might mix filtering, sorting, formatting, and user-interface updates in one large method. Such code becomes difficult to test and reuse.

Analysis and approach

Separate the transformation into small functions and use higher-order collection methods:

func importantOpenTasks(from tasks: [Task]) -> [Task] {
    tasks
        .filter { !$0.isComplete }
        .sorted { first, second in
            first.priority > second.priority
        }
}

func titles(for tasks: [Task]) -> [String] {
    tasks.map { $0.title }
}

The first function does not mutate tasks; it creates a filtered and sorted result. The second function performs a separate projection from task models to display titles.

A view model could then compose the operations:

let selected = importantOpenTasks(from: allTasks)
let displayTitles = titles(for: selected)

Outcome

The design makes each step independently testable. A test can verify that completed tasks are excluded, that priorities descend, and that titles are mapped correctly. The user-interface layer receives prepared data rather than implementing business rules.

Learning points

• Function names should express intent.
• Pure transformations are easier to test because they do not modify shared state.
• Closures make collection processing concise without hiding the algorithm.
• Sorting rules must be explicit and consistent.
• Separating data preparation from presentation supports maintainable iOS architecture.

Best Practices and Limitations

1. Choose informative labels. A call should communicate what each argument means.
2. Keep functions focused. A function with many unrelated responsibilities is a maintenance warning.
3. Prefer clear return types. Use optionals for absence, throwing functions for explainable failure, and structures for substantial results.
4. Avoid unnecessary mutation. Returning a value is often easier to reason about than modifying an inout argument.
5. Use closures deliberately. Concision should not reduce readability.
6. Manage ownership. Inspect escaping closures for retain cycles, especially in view controllers and long-lived services.
7. Prefer standard higher-order methods when appropriate. They express common transformations clearly, but a conventional loop may be better when complex control flow or performance analysis is required.
8. Test edge cases. Empty collections, invalid input, duplicate values, and asynchronous failure paths should be considered.

There are trade-offs. Chains of map, filter, and reduce can create expressive code, but excessively long chains may be harder to debug. Closures can reduce boilerplate, but deeply nested closures can obscure control flow. Functional designs reduce shared mutation, yet some systems legitimately require stateful objects. Good Swift programming balances abstraction with clarity.

Contemporary Relevance

Swift's function and closure model supports modern iOS patterns, including dependency injection, reactive streams, structured concurrency, and declarative user interfaces. Functions can be injected into view models for testing, while closures can represent event handlers and transformation policies. With async functions, asynchronous work can be expressed in a sequential style, although callback closures remain common at API boundaries.

Artificial intelligence features in mobile applications also depend on these fundamentals. A prediction service may accept a completion closure, a preprocessing function, or a filtering policy. The same concerns apply: define clear contracts, represent failure explicitly, avoid retain cycles, and protect user data. Closure design does not remove the need for privacy, security, or responsible data handling.

Chapter Summary

Functions provide named contracts for reusable behavior. Swift separates argument labels from local parameter names, enabling calls that are both safe and readable. Default parameters provide controlled convenience, while variadic parameters accept a variable number of values. Return values, optionals, tuples, and throwing functions allow an API to communicate successful and unsuccessful outcomes.

inout parameters permit controlled mutation but should be used selectively. Nested functions and function types allow behavior to be stored, passed, and returned. Closures are unnamed functions that can capture surrounding values, maintain state, and serve as callbacks. Escaping closures require special attention to lifetime and ownership, particularly in iOS applications.

Higher-order functions such as map, filter, reduce, compactMap, and sorted support expressive collection processing. The strongest designs combine these tools with focused responsibilities, meaningful labels, explicit error behavior, testability, and careful memory management.

Key Terms

Function: A named block of reusable code that may accept inputs and produce an output.

Parameter: A named input declared by a function.

Argument label: The name written at a function call site.

Default parameter: A parameter supplied with a value used when the caller omits it.

Variadic parameter: A parameter that accepts zero or more values of one type.

Return value: The result produced by a function.

Optional: A type that may contain a value or no value.

Tuple: A compound value containing multiple related elements.

Throwing function: A function that can report failure by throwing an error.

inout: A parameter modifier that permits a function to modify the caller's variable.

Nested function: A function declared within another function.

Function type: A type describing a function's parameter types and return type.

Closure: An unnamed, self-contained block of executable code.

Capture: The retention of values or references from a closure's surrounding context.

Capture list: Syntax controlling how a closure retains captured values or references.

Escaping closure: A closure that may execute after the function receiving it has returned.

Higher-order function: A function that accepts or returns another function or closure.

map: A method that transforms each collection element.

filter: A method that retains elements satisfying a condition.

reduce: A method that combines collection elements into one accumulated result.

Review Questions

5 Short Answer Questions

1. What is the difference between an argument label and a parameter name in Swift?
2. When is a default parameter appropriate?
3. Why might a function return an optional value?
4. What does the inout modifier allow a function to do?
5. What is the purpose of a closure capture list?

5 Long Answer Questions

1. Explain how function types enable functions to be passed as arguments and returned as results. Include a Swift example.
2. Compare map, filter, and reduce, including the kind of result each method produces.
3. Discuss the benefits and risks of using escaping closures in an iOS application.
4. Explain how argument labels contribute to API readability and misuse prevention.
5. Compare returning a new value with modifying an inout parameter. When might each approach be suitable?

3 Analytical / Application Questions

1. Design a function that accepts an array of optional integers, removes missing values, and returns the values in descending order. Explain which higher-order functions you would use and why.
2. An iOS view controller stores a completion closure that refers strongly to the view controller itself. Analyze the memory-management problem and propose a safer capture strategy.
3. A team has written one 100-line function that validates input, saves data, sorts results, and updates the user interface. Propose a decomposition into smaller functions and justify the boundaries you choose.

Multiple Choice Questions with Answers

Question 1

Which call correctly invokes func send(message: String, to recipient: String)?

A. send("Hello", "Sam")

B. send(message: "Hello", to: "Sam")

C. send(message: "Hello", recipient: "Sam")

D. send(to: "Sam", message: "Hello")

Correct Answer: B. send(message: "Hello", to: "Sam")

Question 2

What does a variadic parameter allow a function to receive?

A. Exactly one optional value

B. Only values of different types

C. Zero or more values of the same declared type

D. A dictionary of named values

Correct Answer: C. Zero or more values of the same declared type

Question 3

Why does the average example return Double??

A. Because Swift cannot perform addition on doubles

B. Because an empty collection has no defined average

C. Because variadic parameters always return optionals

D. Because all numeric functions must return optionals

Correct Answer: B. Because an empty collection has no defined average

Question 4

Which syntax passes a variable to an inout parameter?

A. function(value)

B. function(let value)

C. function(&value)

D. function(inout value)

Correct Answer: C. function(&value)

Question 5

What is the function type of a function accepting two Int values and returning an Int?

A. (Int, Int) -> Int

B. (Int) -> (Int, Int)

C. Int -> Int -> Int

D. (Int, Int) => Int

Correct Answer: A. (Int, Int) -> Int

Question 6

What does filter do to a collection?

A. Transforms every element into a different type

B. Combines all elements into one value

C. Retains elements for which its closure returns true

D. Reverses the collection in place

Correct Answer: C. Retains elements for which its closure returns true

Question 7

What is a principal risk when an escaping closure strongly captures its owning object?

A. Integer overflow

B. A retain cycle

C. Loss of argument labels

D. Automatic sorting failure

Correct Answer: B. A retain cycle

Question 8

In numbers.map { $0 * $0 }, what does $0 represent?

A. The first element of the resulting collection

B. The closure's first parameter

C. The collection's index value only

D. The accumulated result

Correct Answer: B. The closure's first parameter

Question 9

Which capture modifier creates a weak optional reference?

A. [strong self]

B. [value self]

C. [weak self]

D. [copy self]

Correct Answer: C. [weak self]

Question 10

What is the result of [4, 6, 10].reduce(0) { total, value in total + value }?

A. 10

B. 16

C. 20

D. 24

Correct Answer: C. 20