Trailing closure syntax in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of trailing closure with single parameter

What is the output of this Swift code using trailing closure syntax?

Swift

func greet(name: String, action: (String) -> String) {
    print(action(name))
}

greet(name: "Alice") { name in
    "Hello, \(name)!"
}

A Hello, Alice!

B Hello, name!

C greet(name: "Alice")

D Error: Missing return statement

💡 Hint

Trailing closures let you write the closure outside the parentheses.

The function greet takes a name and a closure that returns a greeting string. The trailing closure syntax passes the closure after the function call parentheses. The closure returns "Hello, Alice!" which is printed.

❓ Predict Output

intermediate

Trailing closure with multiple parameters

What will be printed by this Swift code using trailing closure syntax?

Swift

func combine(_ a: Int, _ b: Int, operation: (Int, Int) -> Int) {
    print(operation(a, b))
}

combine(3, 4) { x, y in
    x * y
}

A Error: Missing parentheses

B 7

C 12

D 34

💡 Hint

The closure multiplies the two numbers.

The combine function takes two integers and a closure that returns an integer. The trailing closure multiplies 3 and 4, resulting in 12, which is printed.

🔧 Debug

advanced

Identify the error in trailing closure usage

What error does this Swift code produce?

Swift

func repeatTask(times: Int, task: () -> Void) {
    for _ in 0..<times {
        task()
    }
}

repeatTask(times: 3) {
    print("Hello")
}

A RuntimeError: Infinite loop

B SyntaxError: Unexpected newline

C TypeError: task is not a function

D No error, prints "Hello" 3 times

💡 Hint

Trailing closure syntax is correct here.

The code correctly uses trailing closure syntax to pass a closure that prints "Hello". The function calls the closure 3 times, printing "Hello" 3 times without error.

❓ Predict Output

advanced

Trailing closure with multiple closures

What is the output of this Swift code with multiple trailing closures?

Swift

func perform(action: () -> Void, completion: () -> Void) {
    action()
    completion()
}

perform {
    print("Action done")
} completion: {
    print("Completion done")
}

A SyntaxError: Unexpected token 'completion:'

B Action done\nCompletion done

C RuntimeError: Missing completion closure

D Completion done\nAction done

💡 Hint

Swift supports multiple trailing closures with labels.

The perform function takes two closures. The first trailing closure is for action, the second labeled trailing closure is for completion. The output prints "Action done" then "Completion done".

🧠 Conceptual

expert

Why use trailing closure syntax?

Which of the following is the main advantage of using trailing closure syntax in Swift?

A It allows passing closures outside parentheses for cleaner and more readable code.

B It forces closures to be written inline inside the parentheses.

C It disables the use of multiple closures in a function call.

D It automatically converts closures to asynchronous functions.

💡 Hint

Think about code readability and syntax style.

Trailing closure syntax lets you write a closure after the function call parentheses, making code cleaner and easier to read, especially when the closure is long or the last argument.