Fair warning: closures are widely considered the hardest topic in Swift. So if you read this and feel your brain doing something uncomfortable, that's completely normal. You're not missing something everyone else gets — closures genuinely take time to click, and even experienced Swift developers remember struggling with them at first. 🍥

Think of it like cycling uphill. It's hard while you're doing it. But once you reach the top, everything that comes after gets much easier — and in SwiftUI, closures are everywhere, so the climb is worth it.

Let's take it one small step at a time.

What Even Is a Closure?

You already know what a function is:

func greetUser() {
    print("Hi there!")
}

greetUser()

Now here's something surprising — you can copy a function into a variable:

var greetCopy = greetUser
greetCopy()

Notice: no parentheses after greetUser when copying. If you wrote greetUser(), you'd be calling the function and storing its return value — not copying the function itself.

So greetCopy now holds the entire function. You can call it just like the original.

Creating a Closure Directly

What if you skipped writing a named function entirely, and just assigned the code directly to a variable?

let sayHello = {
    print("Hi there!")
}

sayHello()

That chunk of code inside { } is a closure — an anonymous function stored in a variable. No func keyword, no name, just the code itself. Swift calls it a "closure expression," but the important thing is: it's a chunk of code you can store, pass around, and call whenever you need it.

Adding Parameters and a Return Type

Here's where the syntax gets a little different. With a regular function, parameters go outside the braces:

func sayHello(name: String) -> String {
    "Hi \(name)!"
}

But with a closure, everything has to go inside the braces — because the braces are the whole thing. Swift uses a special keyword, in, to separate the parameters and return type from the actual body of the closure:

let sayHello = { (name: String) -> String in
    "Hi \(name)!"
}

Breaking that down:

• (name: String) — the parameter, inside the braces
• -> String — the return type, also inside the braces
• in — marks the end of the "header" and the start of the actual code
• "Hi \(name)!" — the body of the closure

Think of in as Swift saying: "parameters done, code starts here."

Why Are Parameters Inside the Braces?

You might be wondering why closures work this way. Here's the reason:

If parameters were outside the braces, like this:

let payment = (user: String, amount: Int) // ❌ This looks like a tuple!

Swift would think you're creating a tuple, not a closure. Moving them inside the braces makes it unambiguous — the whole thing (parameters + body) is one self-contained chunk stored in a variable.

No Parameters, But Still Returns a Value

One edge case worth knowing: if your closure takes no parameters but does return a value, you can't just write -> Bool in. You need empty parentheses to make it clear:

let payment = { () -> Bool in
    print("Paying an anonymous person…")
    return true
}

This mirrors how regular functions work: func payment() -> Bool. Same idea, just written inside the braces.

Function Types

Every function (and closure) has a type — based on what it takes in and what it sends back.

var greetCopy: () -> Void = greetUser

Breaking that down:

• () — takes no parameters
• -> — here comes the return type
• Void — returns nothing (sometimes written as (), but Void is clearer)

Here's a more interesting example:

func getUserData(for id: Int) -> String {
    if id == 1989 {
        return "Taylor Swift"
    } else {
        return "Anonymous"
    }
}

let data: (Int) -> String = getUserData
let user = data(1989)
print(user)

Notice something: when we copied getUserData into data, the external parameter label for disappeared. The function type is (Int) -> String — not (for id: Int) -> String. Parameter labels are not part of a function's type. So when you call the copy, you don't use the label:

data(1989)       // ✅ correct
data(for: 1989)  // ❌ wrong — no label on copies or closures

Passing Functions Into Functions

Here's where things start getting really powerful 🌟

Swift's sorted() function sorts an array alphabetically by default:

let team = ["Gloria", "Suzanne", "Piper", "Tiffany", "Tasha"]
let sortedTeam = team.sorted()
print(sortedTeam) // ["Gloria", "Piper", "Suzanne", "Tasha", "Tiffany"]

But what if Suzanne is the team captain and should always come first? sorted() lets you pass in a custom sorting function — one that accepts two strings and returns a Bool indicating which should come first:

func captainFirstSorted(name1: String, name2: String) -> Bool {
    if name1 == "Suzanne" {
        return true   // Suzanne goes first
    } else if name2 == "Suzanne" {
        return false  // Suzanne goes first (so name1 goes after)
    }
    return name1 < name2  // normal alphabetical for everyone else
}

let captainFirstTeam = team.sorted(by: captainFirstSorted)
print(captainFirstTeam) // ["Suzanne", "Gloria", "Piper", "Tasha", "Tiffany"]

We passed captainFirstSorted — an entire function — as an argument to sorted(). That's the power of functions being first-class values in Swift.

Passing a Closure Directly

Now here's where closures really shine. Instead of writing a separate named function just for one use, we can pass the logic directly as a closure:

let captainFirstTeam = team.sorted(by: { (name1: String, name2: String) -> Bool in
    if name1 == "Suzanne" {
        return true
    } else if name2 == "Suzanne" {
        return false
    }
    return name1 < name2
})

This does exactly the same thing as before — but without needing a separate captainFirstSorted function. The logic lives right where it's used.

Let's break down what's happening:

• team.sorted(by:) — calling sorted with a custom comparator
• { (name1: String, name2: String) -> Bool in — opening the closure, declaring its parameters, return type, and the in keyword
• The body is the same sorting logic as before
• The whole closure ends with }) — closing both the closure } and the function call )

Yes, that last line is a little punctuation-heavy. The next article will show you how Swift lets you simplify this syntax dramatically — but understanding the full form first makes those shortcuts make sense.

Why Do Closures Matter So Much?

Closures let you store "work to do later" in a variable. Some real-world examples:

• Run some code after a delay
• Run some code after an animation finishes
• Run some code when a download completes
• Run some code when a user taps a button

In every one of those cases, you're saying: "here's what I want to happen — but not right now." That's exactly what a closure is.

And in SwiftUI? Closures are literally everywhere. Every Button, every .onAppear, every animation — closures. Understanding them now means SwiftUI will feel far more natural later.

Quick Recap

Wrap Up

Closures are hard — but now you've seen the full picture: what they are, why parameters live inside the braces, what function types look like, and how to pass closures directly into functions like sorted().

If it still feels a bit wobbly, that's okay. Read it again, try the examples in a playground, and let the concept settle. The next article will show you how Swift lets you simplify closure syntax significantly — and once that clicks, you'll wonder why you ever found them scary. 🌸

I know these Swift concepts well from hands-on practice — I use AI to help draft and organize my explanations, and every example and structure choice is something I've reviewed and stand behind.