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.

Practice

1. What does trailing closure syntax allow you to do in Swift?
func perform(action: () -> Void) { action() }

easy

A. Write the last closure argument outside the parentheses

B. Use closures only inside parentheses

C. Avoid using closures altogether

D. Write closures only as named functions

Solution

1. Step 1: Understand closure arguments in Swift functions

   Swift functions can take closures as arguments, usually inside parentheses.

2. Step 2: Identify trailing closure syntax purpose

   Trailing closure syntax lets you write the last closure argument outside the parentheses for cleaner code.

3. Final Answer:

   Write the last closure argument outside the parentheses -> Option A

4. Quick Check:

   Trailing closure syntax = last closure outside parentheses [OK]

Hint: Last closure can go outside parentheses for clarity [OK]

Common Mistakes:

• Thinking closures must always be inside parentheses
• Confusing trailing closures with named functions
• Believing trailing closures remove closures entirely

2. Which of the following is the correct way to use trailing closure syntax in Swift?

func greet(action: () -> Void) { action() }

easy

A. greet() { print("Hello") }

B. greet { print("Hello") }

C. greet { print("Hello") }()

D. greet(print("Hello"))

Solution

1. Step 1: Recall trailing closure syntax format

   Trailing closure syntax allows calling a function with a closure outside parentheses if it's the last argument.

2. Step 2: Check each option

   greet { print("Hello") } correctly calls greet with closure outside parentheses: greet { print("Hello") }.

3. Final Answer:

   greet { print("Hello") } -> Option B

4. Quick Check:

   Trailing closure syntax = function { closure } [OK]

Hint: Use braces after function name without parentheses for trailing closure [OK]

Common Mistakes:

• Adding empty parentheses before trailing closure
• Trying to call closure immediately with () after braces
• Passing closure as a normal argument inside parentheses

3. What is the output of this Swift code?

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

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

medium

A. Hi
Hi
Hi

B. Hi Hi Hi

C. Hi Hi

D. Error: Missing parentheses

Solution

1. Step 1: Understand repeatTask function behavior

   The function calls the closure 'task' the number of times specified by 'times'. Here, times = 3.

2. Step 2: Analyze the closure call

   The closure prints "Hi" each time. So it prints "Hi" three times, each on a new line because print adds a newline.

3. Final Answer:

   Hi Hi Hi -> Option A

4. Quick Check:

   3 prints of "Hi" each on new line = Hi Hi Hi [OK]

Hint: print adds newline, so repeated prints appear on separate lines [OK]

Common Mistakes:

• Assuming prints appear on same line without newline
• Thinking trailing closure causes syntax error
• Confusing number of repetitions

4. Identify the error in this Swift code using trailing closure syntax:

func calculate(operation: (Int, Int) -> Int) {
    let result = operation(5, 3)
    print(result)
}

calculate() { (a, b) in
    a + b
}

medium

A. Trailing closure syntax cannot be used here

B. Missing return keyword inside closure

C. Closure parameters should be outside parentheses

D. Extra parentheses after calculate() when using trailing closure

Solution

1. Step 1: Check function call syntax with trailing closure

   When using trailing closure syntax, do not include empty parentheses before the closure.

2. Step 2: Identify the error in code

   The code calls calculate() with empty parentheses and then a trailing closure, which is incorrect syntax.

3. Final Answer:

   Extra parentheses after calculate() when using trailing closure -> Option D

4. Quick Check:

   Trailing closure means no parentheses if no other arguments [OK]

Hint: Remove empty parentheses when using trailing closure [OK]

Common Mistakes:

• Including empty parentheses before trailing closure
• Adding unnecessary return in single-expression closure
• Thinking trailing closure can't have parameters

5. Given this Swift function:

func fetchData(completion: (String) -> Void) {
    let data = "User info"
    completion(data)
}

How would you call fetchData using trailing closure syntax to print the data received?

hard

A. fetchData() { data in print(data) }

B. fetchData(completion: { data in print(data) })

C. fetchData { data in print(data) }

D. fetchData { print(data) }

Solution

1. Step 1: Understand trailing closure syntax for single closure argument

   When the last argument is a closure, you can write it outside parentheses without empty parentheses.

2. Step 2: Check each option for correct syntax and usage

   fetchData { data in print(data) } correctly calls fetchData with trailing closure and closure parameter 'data' used inside print.

3. Final Answer:

   fetchData { data in print(data) } -> Option C

4. Quick Check:

   Trailing closure with parameter = fetchData { data in print(data) } [OK]

Hint: Write closure after function name without parentheses for trailing closure [OK]

Common Mistakes:

• Including empty parentheses before trailing closure
• Omitting closure parameter when needed
• Trying to use closure inside parentheses and trailing closure simultaneously