Shorthand argument names ($0, $1) in Swift - Mini Project: Build & Apply

Using Shorthand Argument Names ($0, $1) in Swift

📖 Scenario: Imagine you are organizing a small party and you have a list of guests with their ages. You want to create a new list that shows only the guests who are adults (18 years or older).

🎯 Goal: You will learn how to use shorthand argument names $0 and $1 in Swift closures to filter and sort the guest list easily.

📋 What You'll Learn

Create a dictionary called guests with the exact entries: "Anna": 22, "Ben": 17, "Cara": 19, "David": 15, "Eva": 20

Create a variable called ageLimit and set it to 18

Use the filter method with a closure using shorthand argument name $0 to keep guests who are 18 or older

Use the sorted method with a closure using shorthand argument names $0 and $1 to sort guests by their names alphabetically

Print the filtered and sorted list of guests

💡 Why This Matters

🌍 Real World

Filtering and sorting data is common when managing lists like guest lists, contacts, or products.

💼 Career

Understanding shorthand argument names helps write concise and readable Swift code, useful for iOS app development.

1

Create the guest list dictionary

Create a dictionary called guests with these exact entries: "Anna": 22, "Ben": 17, "Cara": 19, "David": 15, "Eva": 20

Swift

# Create the dictionary called guests with the given entries
# Your code here

Hint

Use square brackets [] to create a dictionary with key-value pairs.

2

Set the age limit variable

Create a variable called ageLimit and set it to 18

Swift

let guests = ["Anna": 22, "Ben": 17, "Cara": 19, "David": 15, "Eva": 20]
# Create the variable ageLimit and set it to 18
# Your code here

Hint

Use let to create a constant variable.

3

Filter guests who are adults using shorthand argument name

Use the filter method on guests with a closure using the shorthand argument name $0 to keep only guests whose age is greater than or equal to ageLimit. Store the result in a variable called adultGuests.

Swift

let guests = ["Anna": 22, "Ben": 17, "Cara": 19, "David": 15, "Eva": 20]
let ageLimit = 18
# Filter guests to keep only adults using $0
# Your code here

Hint

Inside the closure, $0 represents each key-value pair (a tuple). Use $0.value to access the age.

4

Sort and print the adult guests

Use the sorted method on adultGuests with a closure using shorthand argument names $0 and $1 to sort guests by their names alphabetically. Then print the sorted list.

Swift

let guests = ["Anna": 22, "Ben": 17, "Cara": 19, "David": 15, "Eva": 20]
let ageLimit = 18
let adultGuests = guests.filter { $0.value >= ageLimit }
# Sort adultGuests by name using $0 and $1 and print the result
# Your code here

Hint

Use $0.key and $1.key to compare guest names inside the closure.

Practice

1. What does the shorthand argument $0 represent in a Swift closure?

easy

A. The last argument passed to the closure

B. The first argument passed to the closure

C. The closure itself

D. The return value of the closure

Solution

1. Step 1: Understand shorthand argument names

   In Swift closures, $0 refers to the first argument passed to the closure.

2. Step 2: Identify $0 meaning

   Since $0 is always the first argument, it represents the first input value the closure receives.

3. Final Answer:

   The first argument passed to the closure -> Option B

4. Quick Check:

   $0 = first argument [OK]

Hint: Remember $0 is always the first input in closures [OK]

Common Mistakes:

• Confusing $0 with the return value
• Thinking $0 is the closure itself
• Mixing $0 with the last argument

2. Which of the following is the correct way to use shorthand argument names to sort an array of integers in ascending order?

easy

A. let sorted = numbers.sorted { $1 > $0 }

B. let sorted = numbers.sorted { $1 < $0 }

C. let sorted = numbers.sorted { $0 > $1 }

D. let sorted = numbers.sorted { $0 < $1 }

Solution

1. Step 1: Understand sorting with closures

   To sort ascending, the closure should return true if the first element is less than the second.

2. Step 2: Match shorthand arguments to sorting logic

   Using $0 < $1 means the first element is less than the second, which sorts ascending.

3. Final Answer:

   let sorted = numbers.sorted { $0 < $1 } -> Option D

4. Quick Check:

   Ascending sort uses $0 < $1 [OK]

Hint: Use $0 < $1 for ascending sort closures [OK]

Common Mistakes:

• Reversing $0 and $1 in comparison
• Using > instead of < for ascending
• Confusing sorting order logic

3. What is the output of the following Swift code?

let names = ["Anna", "Bob", "Charlie"]
let reversed = names.map { String($0.reversed()) }
print(reversed)

medium

A. ["annA", "boB", "eilrahc"]

B. ["Anna", "Bob", "Charlie"]

C. ["annA", "boB", "eilrahC"]

D. ["a n n A", "b o B", "c h a r l i e"]

Solution

1. Step 1: Understand the map and reversed usage

   The map applies the closure to each name. $0 is each string. $0.reversed() reverses characters.

2. Step 2: Convert reversed characters back to String

   Wrapping String($0.reversed()) creates a reversed string for each name.

3. Final Answer:

   ["annA", "boB", "eilrahC"] -> Option C

4. Quick Check:

   map + reversed string = reversed names [OK]

Hint: Remember map applies closure to each element using $0 [OK]

Common Mistakes:

• Forgetting to convert reversed characters back to String
• Expecting original array without changes
• Confusing reversed string with spaced characters

4. Identify the error in this Swift code using shorthand argument names:

let numbers = [3, 1, 2]
let sorted = numbers.sorted { $2 < $1 }
print(sorted)

medium

A. Using $2 which does not exist in this closure

B. Missing return keyword in closure

C. Incorrect array declaration syntax

D. Using sorted instead of sort method

Solution

1. Step 1: Check shorthand argument usage

   Shorthand arguments start at $0 for the first, $1 for the second. There is no $2 in a two-argument closure.

2. Step 2: Identify invalid argument index

   Using $2 causes a compile error because only $0 and $1 exist here.

3. Final Answer:

   Using $2 which does not exist in this closure -> Option A

4. Quick Check:

   Only $0 and $1 allowed in two-argument closures [OK]

Hint: Use only $0 and $1 for two-parameter closures [OK]

Common Mistakes:

• Assuming $2 exists in two-argument closures
• Forgetting shorthand argument limits
• Confusing sorted and sort method differences

5. Given the array let pairs = [(3, 5), (1, 2), (4, 4)], which closure using shorthand argument names correctly sorts the array by the sum of each tuple's elements in descending order?

hard

A. pairs.sorted { $0.0 + $0.1 > $1.0 + $1.1 }

B. pairs.sorted { $1.0 + $1.1 > $0.0 + $0.1 }

C. pairs.sorted { $0 + $1 > $1 + $0 }

D. pairs.sorted { $0.0 > $1.1 }

Solution

1. Step 1: Understand tuple access and sorting logic

   Each element is a tuple. To sort by sum descending, compare sums of $0 and $1 tuples.

2. Step 2: Check each option's correctness

   pairs.sorted { $0.0 + $0.1 > $1.0 + $1.1 } sums $0.0 + $0.1 and compares to $1.0 + $1.1 with > for descending order, which is correct.

3. Final Answer:

   pairs.sorted { $0.0 + $0.1 > $1.0 + $1.1 } -> Option A

4. Quick Check:

   Sum tuples and use > for descending sort [OK]

Hint: Sum tuple elements with $0.0 + $0.1 for sorting [OK]

Common Mistakes:

• Mixing $0 and $1 order in comparison
• Trying to add tuples directly without accessing elements
• Using incorrect tuple element indices