Closure expression syntax in Swift - Mini Project: Build & Apply

Closure Expression Syntax in Swift

📖 Scenario: Imagine you are organizing a small event and you have a list of guest names. You want to sort this list alphabetically but with a twist: you want to sort it in reverse order using a simple function. Swift closures let you write this sorting logic in a neat and short way.

🎯 Goal: You will create a list of guest names, then write a closure expression to sort the list in reverse alphabetical order, and finally print the sorted list.

📋 What You'll Learn

Create an array called guests with the exact names: "Anna", "Brian", "Craig", "Diana"

Create a closure expression called reverseSort that takes two String parameters and returns Bool indicating if the first string should come before the second in reverse alphabetical order

Use the reverseSort closure to sort the guests array

Print the sorted guests array

💡 Why This Matters

🌍 Real World

Closures are used in Swift to write short, reusable blocks of code that can be passed around, like sorting lists or handling user actions.

💼 Career

Understanding closure syntax is important for iOS app development and working with Swift frameworks that use closures for callbacks and event handling.

1

Create the guest list

Create an array called guests with these exact names: "Anna", "Brian", "Craig", "Diana"

Swift

# Create the guests array with the exact names
# Your code here

Hint

Use square brackets [] to create an array and separate names with commas.

2

Create the reverse sort closure

Create a closure expression called reverseSort that takes two String parameters named a and b and returns Bool. The closure should return true if a is greater than b (to sort in reverse alphabetical order).

Swift

var guests = ["Anna", "Brian", "Craig", "Diana"]

// Create the reverseSort closure here
# Your code here

Hint

Use the closure syntax: { (parameters) -> returnType in statements }.

3

Sort the guests using the closure

Use the reverseSort closure to sort the guests array and assign the result back to guests.

Swift

var guests = ["Anna", "Brian", "Craig", "Diana"]

let reverseSort = { (a: String, b: String) -> Bool in
    return a > b
}

// Sort guests using reverseSort closure
# Your code here

Hint

Use the sorted(by:) method with the closure as argument.

4

Print the sorted guest list

Print the guests array to show the sorted names.

Swift

var guests = ["Anna", "Brian", "Craig", "Diana"]

let reverseSort = { (a: String, b: String) -> Bool in
    return a > b
}

guests = guests.sorted(by: reverseSort)

// Print the sorted guests array
# Your code here

Hint

Use print(guests) to display the array.

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