Closure expression syntax in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this closure expression?

Consider the following Swift code using a closure expression. What will be printed when this code runs?

Swift

let numbers = [1, 2, 3, 4]
let doubled = numbers.map({ (num: Int) -> Int in
    return num * 2
})
print(doubled)

A [4, 8, 12, 16]

B [1, 2, 3, 4]

C Compilation error

D [2, 4, 6, 8]

💡 Hint

Look at how the closure multiplies each number by 2.

The closure takes each number and returns it multiplied by 2, so the map function produces a new array with doubled values.

❓ Predict Output

intermediate

What does this shorthand closure print?

What is the output of this Swift code using shorthand argument names in a closure?

Swift

let names = ["Anna", "Alex", "Brian", "Jack"]
let sortedNames = names.sorted(by: { $0 > $1 })
print(sortedNames)

A ["Jack", "Brian", "Alex", "Anna"]

B Runtime error

C ["Alex", "Anna", "Brian", "Jack"]

D ["Anna", "Alex", "Brian", "Jack"]

💡 Hint

The closure sorts names in descending order.

The closure compares two names and returns true if the first is greater than the second, so the array is sorted in reverse alphabetical order.

🔧 Debug

advanced

Identify the error in this closure syntax

This Swift code tries to filter an array using a closure but causes a compile error. What is the error?

Swift

let numbers = [1, 2, 3, 4, 5]
let evens = numbers.filter { num in
    num % 2 == 0
}

print(evens)

A Missing closing brace '}' for the closure

B Missing return keyword inside the closure

C Incorrect use of parentheses in filter call

D Using 'num' instead of '$0' causes error

💡 Hint

Check if all braces are properly closed.

The closure is missing a closing brace '}', causing a syntax error.

❓ Predict Output

advanced

What is the output of this nested closure?

What will this Swift code print when run?

Swift

func makeIncrementer(amount: Int) -> () -> Int {
    var total = 0
    return {
        total += amount
        return total
    }
}

let incrementByTen = makeIncrementer(amount: 10)
print(incrementByTen())
print(incrementByTen())

A 0\n10

B Compilation error

C 10\n20

D 10\n10

💡 Hint

The closure captures and updates 'total' each time it is called.

The closure remembers the 'total' variable and adds 'amount' each call, so first call returns 10, second returns 20.

🧠 Conceptual

expert

Which option correctly explains trailing closure syntax?

In Swift, which statement best describes the trailing closure syntax?

A Trailing closures must always have explicit parameter types declared.

B A closure passed as the last argument can be written outside the parentheses of the function call.

C Trailing closures cannot capture variables from the surrounding context.

D Trailing closures are only allowed if the function has exactly one parameter.

💡 Hint

Think about how you can write closures after function calls.

Trailing closure syntax lets you write a closure outside the parentheses if it is the last argument, making code cleaner.

Practice

1. What is a closure in Swift?

easy

A. A special kind of loop for repeating tasks

B. A block of code that can be passed around and executed later

C. A type of variable that stores numbers only

D. A keyword used to declare functions

Solution

1. Step 1: Understand the definition of closure

   A closure is a block of code that can be saved and run later, similar to a function but more flexible.

2. Step 2: Compare options with closure meaning

   Only 'A block of code that can be passed around and executed later' correctly describes a closure.

3. Final Answer:

   A block of code that can be passed around and executed later -> Option B

4. Quick Check:

   Closure = block of code passed and run later [OK]

Hint: Closures are like saved code blocks you run later [OK]

Common Mistakes:

• Confusing closures with variables
• Thinking closures are loops
• Mixing closures with function keywords

2. Which of the following is the correct syntax for a closure that takes two Ints and returns their sum?

easy

A. { a, b in a + b }

B. { (a, b) -> Int { a + b } }

C. func sum(a: Int, b: Int) -> Int { return a + b }

D. { (a: Int, b: Int) -> Int in return a + b }

Solution

1. Step 1: Identify closure syntax components

   A closure with parameters and return type uses parentheses for parameters, '->' for return type, and 'in' before the code.

2. Step 2: Check each option

   { (a: Int, b: Int) -> Int in return a + b } correctly uses (a: Int, b: Int) -> Int in return a + b. { a, b in a + b } omits types and requires context for type inference to compile. func sum(a: Int, b: Int) -> Int { return a + b } is a function, not a closure. { (a, b) -> Int { a + b } } has wrong braces placement and misses 'in'.

3. Final Answer:

   { (a: Int, b: Int) -> Int in return a + b } -> Option D

4. Quick Check:

   Closure syntax = parameters, return type, in keyword [OK]

Hint: Closure syntax: parameters, arrow, return type, then 'in' [OK]

Common Mistakes:

• Confusing functions with closures
• Missing 'in' keyword
• Incorrect braces placement

3. What is the output of this Swift code?

let multiply = { (x: Int, y: Int) -> Int in x * y }
print(multiply(3, 4))

medium

A. 12

B. 7

C. 34

D. Error

Solution

1. Step 1: Understand closure definition and call

   The closure multiply takes two Ints and returns their product (x * y). It is called with 3 and 4.

2. Step 2: Calculate the result

   3 * 4 = 12, so print outputs 12.

3. Final Answer:

   12 -> Option A

4. Quick Check:

   3 times 4 = 12 [OK]

Hint: Multiply inputs inside closure to get output [OK]

Common Mistakes:

• Adding instead of multiplying
• Concatenating numbers as strings
• Syntax errors in closure call

4. Find the error in this closure syntax:

let greet = { name: String in
  print("Hello, \(name)!")
}

medium

A. Parameters must be in parentheses

B. Missing 'in' keyword after parameters

C. Closure cannot print inside its body

D. Missing parameter types in closure

Solution

1. Step 1: Check closure parameter syntax

   Closure parameters must be enclosed in parentheses, like (name: String).

2. Step 2: Identify the error in given code

   The code uses 'name: String' without parentheses, which is invalid syntax.

3. Final Answer:

   Parameters must be in parentheses -> Option A

4. Quick Check:

   Closure parameters need parentheses [OK]

Hint: Always put closure parameters inside parentheses [OK]

Common Mistakes:

• Omitting parentheses around parameters
• Forgetting 'in' keyword
• Thinking closures can't print

5. How can you simplify this closure expression?

let numbers = [1, 2, 3, 4]
let doubled = numbers.map({ (num: Int) -> Int in return num * 2 })
print(doubled)

hard

A. Use a for loop instead of map

B. Remove 'return' and keep full syntax: numbers.map { (num: Int) -> Int in num * 2 }

C. Use shorthand argument names: numbers.map { $0 * 2 }

D. Cannot simplify closure expressions

Solution

1. Step 1: Understand closure simplification rules

   Swift allows removing parameter types and 'return' when the closure is a single expression, and using shorthand $0 for first parameter.

2. Step 2: Apply shorthand argument names

   Replacing full closure with numbers.map { $0 * 2 } simplifies code and is correct.

3. Final Answer:

   Use shorthand argument names: numbers.map { $0 * 2 } -> Option C

4. Quick Check:

   Shorthand $0 replaces explicit parameters [OK]

Hint: Use $0, $1 for closure parameters to shorten code [OK]

Common Mistakes:

• Keeping full syntax unnecessarily
• Thinking closures can't be simplified
• Replacing map with loops unnecessarily