Omitting argument labels with _ in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift code?

Consider the following Swift function and call:

func greet(_ name: String) {
    print("Hello, \(name)!")
}
greet("Alice")

What will this print?

Swift

func greet(_ name: String) {
    print("Hello, \(name)!")
}
greet("Alice")

A Hello, _Alice!

B Error: Missing argument label

C Hello, Alice!

D Hello, name!

💡 Hint

Check how the underscore (_) affects the argument label when calling the function.

The underscore (_) before the parameter name means the argument label is omitted when calling the function. So, greet("Alice") works without specifying a label.

❓ Predict Output

intermediate

What error does this code produce?

Given this Swift function:

func multiply(_ a: Int, b: Int) -> Int {
    return a * b
}
multiply(a: 3, b: 4)

What error will occur when compiling?

Swift

func multiply(_ a: Int, b: Int) -> Int {
    return a * b
}
multiply(a: 3, b: 4)

A Error: Extraneous argument label 'a:' in call

B Error: Missing argument label 'a:' in call

C 12

D Error: Missing argument label 'b:' in call

💡 Hint

Look at which parameters have labels and which don't.

The first parameter uses an underscore (_) so it has no argument label. Calling with a: 3 is invalid and causes an 'Extraneous argument label' error.

🔧 Debug

advanced

Why does this function call fail?

Examine this Swift code:

func divide(_ numerator: Int, _ denominator: Int) -> Int {
    return numerator / denominator
}
divide(numerator: 10, denominator: 2)

Why does the call to divide fail?

Swift

func divide(_ numerator: Int, _ denominator: Int) -> Int {
    return numerator / denominator
}
divide(numerator: 10, denominator: 2)

A Because the function parameters are constants and cannot be used in division

B Because the function parameters require argument labels, but the call omits them

C Because the function returns an Int but the call expects a Double

D Because the function parameters omit argument labels, but the call uses labels

💡 Hint

Check the use of underscores (_) in the function parameters and how the function is called.

Using underscores means no argument labels are expected when calling the function. The call incorrectly uses labels, causing a compile error.

🧠 Conceptual

advanced

How does the underscore (_) affect argument labels in Swift functions?

Which statement best describes the effect of using an underscore (_) before a parameter name in a Swift function?

A It omits the argument label when calling the function, so only the value is passed.

B It makes the argument label mandatory when calling the function.

C It makes the parameter optional and allows nil values.

D It automatically assigns a default value to the parameter.

💡 Hint

Think about how you call functions with and without argument labels.

The underscore (_) before a parameter name means you do not write the argument label when calling the function. You just pass the value.

❓ Predict Output

expert

What is the output of this Swift code with multiple underscores?

Analyze this Swift code:

func calculate(_ x: Int, _ y: Int, multiplier: Int) -> Int {
    return (x + y) * multiplier
}

let result = calculate(2, 3, multiplier: 4)
print(result)

What will be printed?

Swift

func calculate(_ x: Int, _ y: Int, multiplier: Int) -> Int {
    return (x + y) * multiplier
}

let result = calculate(2, 3, multiplier: 4)
print(result)

A Error: Missing argument label for multiplier

B 20

C Error: Missing argument label for first or second parameter

D 10

💡 Hint

Check which parameters require labels and which do not.

The first two parameters use underscores, so no labels are needed. The third parameter requires the label multiplier:. The call matches this, so the output is (2 + 3) * 4 = 20.

Practice

1. What does the underscore _ do when used before a function parameter in Swift?

easy

A. It changes the parameter type to Any.

B. It makes the parameter optional.

C. It makes the parameter a constant inside the function.

D. It allows you to call the function without writing the argument label.

Solution

1. Step 1: Understand the role of underscore in parameters

   The underscore before a parameter name tells Swift to omit the argument label when calling the function.

2. Step 2: Effect on function call

   This means you can pass the argument directly without naming it, making the call shorter and simpler.

3. Final Answer:

   It allows you to call the function without writing the argument label. -> Option D

4. Quick Check:

   Underscore = omit argument label [OK]

Hint: Underscore means skip argument label when calling [OK]

Common Mistakes:

• Thinking underscore makes parameter optional
• Confusing underscore with type changes
• Assuming underscore affects parameter mutability

2. Which of the following function declarations correctly omits the argument label for the first parameter?

easy

A. func greet(_name: String) { print("Hello, \(_name)!") }

B. func greet(_ name: String) { print("Hello, \(name)!") }

C. func greet(name _ : String) { print("Hello, \(name)!") }

D. func greet(name: String) { print("Hello, \(name)!") }

Solution

1. Step 1: Identify correct underscore usage

   The underscore must appear before the parameter name with a space, like _ name: String.

2. Step 2: Check each option

   func greet(_ name: String) { print("Hello, \(name)!") } uses _ name: String correctly. func greet(name: String) { print("Hello, \(name)!") } uses a label. func greet(name _ : String) { print("Hello, \(name)!") } has wrong syntax. func greet(_name: String) { print("Hello, \(_name)!") } uses an invalid parameter name.

3. Final Answer:

   func greet(_ name: String) { print("Hello, \(name)!") } -> Option B

4. Quick Check:

   Correct underscore syntax = func greet(_ name: String) { print("Hello, \(name)!") } [OK]

Hint: Underscore must be alone before parameter name [OK]

Common Mistakes:

• Putting underscore after parameter name
• Adding spaces between underscore and name incorrectly
• Using underscore as part of parameter name

3. What is the output of this Swift code?

func multiply(_ a: Int, _ b: Int) -> Int {
    return a * b
}

print(multiply(3, 4))

medium

A. 12

B. multiply(3, 4)

C. Error: Missing argument labels

D. 7

Solution

1. Step 1: Understand function parameters with underscore

   Both parameters have underscores, so argument labels are omitted when calling.

2. Step 2: Calculate the function result

   Calling multiply(3, 4) returns 3 * 4 = 12, which is printed.

3. Final Answer:

   12 -> Option A

4. Quick Check:

   3 * 4 = 12 [OK]

Hint: Underscore means call without labels, so multiply(3,4) works [OK]

Common Mistakes:

• Expecting argument labels in call
• Confusing output with string of function call
• Adding parameters incorrectly

4. Identify the error in this Swift function call:

func divide(_ numerator: Double, denominator: Double) -> Double {
    return numerator / denominator
}

divide(10, denominator: 2)

medium

A. Cannot mix omitted and required labels in parameters

B. Missing argument label for denominator

C. No error, code runs fine

D. Missing argument label for numerator

Solution

1. Step 1: Analyze parameter labels

   The first parameter uses underscore, so no label needed. The second requires label denominator.

2. Step 2: Check function call

   The call uses divide(10, denominator: 2), which matches the parameter labels correctly.

3. Final Answer:

   No error, code runs fine -> Option C

4. Quick Check:

   Underscore omits first label, second label required [OK]

Hint: First param no label, second param label required [OK]

Common Mistakes:

• Expecting both labels omitted
• Trying to omit second label incorrectly
• Confusing parameter order

5. You want to write a Swift function formatDate that takes a Date and a String format. You want to call it like formatDate(myDate, "yyyy-MM-dd") without argument labels. Which function declaration is correct?

hard

A. func formatDate(_ date: Date, _ format: String) -> String { /* implementation */ }

B. func formatDate(date: Date, format: String) -> String { /* implementation */ }

C. func formatDate(_ date: Date, format: String) -> String { /* implementation */ }

D. func formatDate(date: Date, _ format: String) -> String { /* implementation */ }

Solution

1. Step 1: Understand call without labels

   Calling formatDate(myDate, "yyyy-MM-dd") means both parameters must omit labels.

2. Step 2: Match function declaration

   Only func formatDate(_ date: Date, _ format: String) -> String { /* implementation */ } uses underscore for both parameters, allowing call without labels.

3. Final Answer:

   func formatDate(_ date: Date, _ format: String) -> String { /* implementation */ } -> Option A

4. Quick Check:

   Both params underscore = no labels in call [OK]

Hint: Use underscore for all params to omit all labels [OK]

Common Mistakes:

• Omitting only one label but calling without both
• Mixing labeled and unlabeled parameters incorrectly
• Forgetting underscore syntax