In the last article, we built our first closure and passed it into sorted(). The result worked perfectly — but the code looked like this:

let heroes = ["Naruto", "Sakura", "Sasuke", "Hinata", "Rock Lee"]

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

That's a lot of syntax. The good news? Swift has three tricks up its sleeve to make this progressively shorter and cleaner — without changing what the code actually does. 🍥

Let's apply each one, step by step.

Trick 1 — Remove the Types (Type Inference)

Remember that sorted() already knows it needs a function that accepts two strings and returns a Bool — that's the only kind of function it accepts. So why are we writing (name1: String, name2: String) -> Bool? Swift already knows all of that.

We can remove the types entirely:

let captainFirstHeroes = heroes.sorted(by: { name1, name2 in
    if name1 == "Naruto" {
        return true
    } else if name2 == "Naruto" {
        return false
    }
    return name1 < name2
})

Swift figures out the types automatically based on context. Our closure went from this crowded header:

(name1: String, name2: String) -> Bool in

To this clean one:

name1, name2 in

Same behaviour, less noise. ✅

Trick 2 — Trailing Closure Syntax

Here's a Swift feature called trailing closure syntax. When the last (or only) parameter of a function is a closure, Swift lets you pull it outside the parentheses and drop the parameter label entirely.

So instead of:

heroes.sorted(by: { name1, name2 in
    ...
})

We can write:

heroes.sorted { name1, name2 in
    ...
}

Notice what changed:

• (by: is gone — we no longer need the parameter label
• The closure moves outside the parentheses
• The closing }) becomes just } — no more awkward bracket combo at the end

This is why you'll often see Swift code with a lone { sitting right after a function name — it's a trailing closure, not magic. 🎉

Why Does This Exist?

The }) at the end of a closure feels a bit uncomfortable to read — it's two closing brackets stacked together with no breathing room. Trailing closure syntax removes that awkwardness, making the code read more naturally:

// Without trailing closure:
animateBattle(duration: 3, animations: {
    print("Naruto charges up his Rasengan...")
})

// With trailing closure:
animateBattle(duration: 3) {
    print("Naruto charges up his Rasengan...")
}

The second version reads almost like plain English: "animate for 3 seconds, then do this." That's exactly the goal. 🌀

Trick 3 — Shorthand Parameter Names ($0, $1)

Swift can go one step further. Instead of naming our parameters at all, Swift can provide automatic names: $0 for the first parameter, $1 for the second, $2 for the third, and so on.

Using shorthand syntax, our sorted() call becomes:

let captainFirstHeroes = heroes.sorted {
    if $0 == "Naruto" {
        return true
    } else if $1 == "Naruto" {
        return false
    }
    return $0 < $1
}

No parameter list, no in keyword — just $0 and $1 representing the two strings being compared. Swift knows what they are because sorted() always passes two values of the same type as the array.

For even simpler closures, this gets really compact. Want to reverse-sort the heroes? Just one line:

let reversedHeroes = heroes.sorted { $0 > $1 }
print(reversedHeroes) // ["Sasuke", "Sakura", "Rock Lee", "Naruto", "Hinata"]

When Should You Use Shorthand Syntax?

Shorthand syntax is powerful — but it's not always the right choice. Here's a simple guide:

✅ Use shorthand when:

• The closure is short (one or two lines)
• Each $0, $1 is only used once or twice
• The function is well-known (sorted, filter, map) so the meaning is clear

❌ Avoid shorthand when:

• The closure is long — named parameters make it easier to follow
• You have three or more parameters ($2, $3 gets confusing fast)
• Each parameter is used multiple times — a name is clearer than repeating $0 everywhere

The goal is always readable code. Shorthand is a tool, not a requirement — use it when it makes things clearer, not just shorter.

Real-World Examples: filter() and map()

Now that you know trailing closures and shorthand syntax, let's look at two more powerful array functions that use them constantly.

filter()

filter() runs a closure on every item in an array and returns a new array containing only the items where the closure returns true:

let heroes = ["Naruto", "Sakura", "Sasuke", "Hinata", "Rock Lee"]

let sHeroes = heroes.filter { $0.hasPrefix("S") }
print(sHeroes) // ["Sakura", "Sasuke"]

Think of it like a ninja selection test — every hero has to pass the condition to make the cut! 🥷

map()

map() transforms every item in an array using a closure, and returns a new array of all the transformed items:

let uppercaseHeroes = heroes.map { $0.uppercased() }
print(uppercaseHeroes) // ["NARUTO", "SAKURA", "SASUKE", "HINATA", "ROCK LEE"]

The original array stays unchanged — map() creates a brand new array with every item transformed. And the return type doesn't have to match the original — you could turn an array of hero names into an array of their name lengths:

let nameLengths = heroes.map { $0.count }
print(nameLengths) // [6, 6, 6, 6, 8]

The Full Journey: From Verbose to Clean

Let's see all three tricks applied in sequence to the same code:

// Full version — verbose but explicit
let captainFirstHeroes = heroes.sorted(by: { (name1: String, name2: String) -> Bool in
    if name1 == "Naruto" { return true }
    else if name2 == "Naruto" { return false }
    return name1 < name2
})

// After Trick 1: remove types
let captainFirstHeroes = heroes.sorted(by: { name1, name2 in
    if name1 == "Naruto" { return true }
    else if name2 == "Naruto" { return false }
    return name1 < name2
})

// After Trick 2: trailing closure syntax
let captainFirstHeroes = heroes.sorted { name1, name2 in
    if name1 == "Naruto" { return true }
    else if name2 == "Naruto" { return false }
    return name1 < name2
}

// After Trick 3: shorthand parameters
let captainFirstHeroes = heroes.sorted {
    if $0 == "Naruto" { return true }
    else if $1 == "Naruto" { return false }
    return $0 < $1
}

Same result, four different ways to write it. Swift accepts all of them — choose the one that makes your code clearest. 🌸

Why This Matters for SwiftUI

You'll use all three of these tricks constantly in SwiftUI — often without even realizing it:

• Every Button uses a trailing closure for its action
• Every List uses a trailing closure to generate its rows
• Even stacking views with VStack uses a trailing closure

Once trailing closure syntax and shorthand parameters feel natural, SwiftUI starts to look clean and readable rather than overwhelming. That's the top of the hill we mentioned last time — and you're almost there! 🚴‍♂️

Wrap Up

This article was written by me; AI was used to improve grammar and readability.