Functions and Closures

By the end of this lesson you'll define your own Swift functions with argument labels, default values, variadic and inout parameters — and write closures (Swift's lambdas) to power map and filter. This is how you stop repeating yourself and start building real logic.

Learn Functions and Closures in our free Swift course — a beginner-friendly interactive lesson with worked examples, a practice exercise and a quick reference.

Part of the free Swift course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

What You'll Learn in This Lesson

1️⃣ Functions, Parameters & Return Types

A function is a named block of code you can run on demand. You declare it with the func keyword, list any parameters (the inputs it needs) in parentheses, and after - > state the return type — the kind of value it hands back. If a function has no - > Type , it returns nothing; it just performs an action. Read this worked example and run it before moving on.

2️⃣ Argument Labels (External vs Internal Names)

This is Swift's signature feature. Each parameter can have two names: an external argument label that you write when you call the function, and an internal parameter name that you use inside the body. Written func greet(person name: String) , callers say greet(person:) while your code uses name — so calls read like sentences. Put _ as the label to omit it entirely at the call site.

Your turn. Finish the function below so its call reads naturally. Replace the two ___ blanks using the // 👉 hints, then run it and confirm the output.

3️⃣ Default Values & Variadic Parameters

Give a parameter a default value with = value and callers can skip it — you write the common case once instead of overloading the function many times. A variadic parameter , written Type... , accepts zero, one, or many arguments; inside the body it arrives as a plain array, so you can loop or reduce over it.

4️⃣ inout Parameters

By default a function receives a copy of each argument and cannot change the caller's variable. An inout parameter changes that: the function works on the original variable. You must pass the argument with an ampersand — double(&score) — so it is obvious at the call site that the variable may be modified. Only a var can be passed to an inout parameter (never a let or a literal).

5️⃣ Closures (Swift's Lambdas)

A closure is an unnamed function you can store in a variable or hand to another function. Its full shape is { (params) - > ReturnType in body } . Closures are how Swift does functional programming: map transforms every element of an array, and filter keeps only the elements that pass a test. When the closure is a function's last argument you can use trailing-closure syntax — move it outside the parentheses — and use $0 , $1 as shorthand for its arguments.

Now you try. Fill in the two trailing closures so the array is transformed and filtered as described. The hints show the exact closure to write.

Putting It Together: an Order Summary

This small program uses everything from the lesson at once — a default value, a variadic parameter, closures with filter and map , and an inout parameter. Read it line by line; you now understand every part.

Common Errors (and the fix)

Pro Tips

• 💡 Name labels for the reader: aim for calls that read aloud, like move(from: a, to: b) .
• 💡 Prefer trailing closures for map / filter / sorted : arr.map { $0 * 2 } is the idiomatic style.
• 💡 Default values beat overloads: one function with sugars: Int = 1 is cleaner than several near-identical functions.
• 💡 Reach for inout sparingly. Returning a new value is usually clearer than mutating the caller's variable.

📋 Quick Reference — Functions & Closures

Pattern

Syntax

Function + return type

func name(p: Type) - > Return

External + internal name

func f(label name: Type)

Omit the label

func f(_ x: Int)

Default value

func f(x: Int = 0)

Variadic

func f(nums: Int...)

inout (call with &)

func f(_ n: inout Int)

Closure

{ (p) - > Return in body }

map / filter (trailing)

arr.map { $0 * 2 }

reduce

arr.reduce(0, +)

Frequently Asked Questions

Mini-Challenge: Discount Calculator

No blanks this time — just a brief and an outline to keep you on track. Write the function yourself, run it, and check your output against the expected results in the comments. This is exactly the kind of small, reusable logic real apps are built from.

🎉 Lesson Complete!

• ✅ func name(p: Type) - > Return packages reusable code; no - > means it returns nothing
• ✅ Parameters have an external label (call site) and an internal name (body); _ omits the label
• ✅ Default values let callers skip arguments; a variadic Type... accepts many
• ✅ inout + & modifies the caller's variable in place
• ✅ Closures are unnamed functions; trailing-closure syntax powers map , filter , and reduce
• ✅ Next lesson: Object-Oriented Programming — model your data with classes, structs, and protocols

Practice quiz

Continue this course

• Previous: Control Flow
• Next: Object-Oriented Programming