Omitting argument labels with _ in Swift - Step-by-Step Execution

Concept Flow - Omitting argument labels with _

Define function with _ before parameter

↓

Call function without argument label

↓

Function receives argument

↓

Execute function body

↓

Return or print result

This flow shows how a function defined with _ before a parameter allows calling it without using the argument label.

Execution Sample

Swift

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

greet("Alice")

Defines a function greet that takes a name without requiring an argument label, then prints a greeting.

Execution Table

Step	Action	Input/Parameter	Output/Print
1	Define function greet with _ for parameter	name: String (no label)
2	Call greet function	"Alice"
3	Function greet receives argument	name = "Alice"
4	Print greeting		Hello, Alice!
5	Function ends

💡 Function completes after printing greeting.

Variable Tracker

Variable	Start	After Call	Final
name	undefined	"Alice"	"Alice"

Key Moments - 2 Insights

Why can we call greet("Alice") without using a label?

Because the function parameter uses _ to omit the argument label, so the call does not require it (see execution_table step 2).

What happens if we try to call greet(name: "Alice")?

It causes an error because the parameter label is omitted with _, so the call must not use a label (refer to execution_table step 2).

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'name' at step 3?

A "Alice"

B undefined

C "Bob"

D nil

💡 Hint

Check the 'Input/Parameter' column at step 3 in the execution_table.

At which step does the function print the greeting?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look at the 'Output/Print' column in the execution_table.

If we remove the _ in the function definition, how would the call change?

A Call changes to greet(_: "Alice")

B Call stays greet("Alice")

C Call changes to greet(name: "Alice")

D Call changes to greet()

💡 Hint

Without _, argument labels are required in Swift function calls.

Concept Snapshot

func functionName(_ parameterName: Type) {
  // code
}

- The _ before parameterName means no label needed when calling.
- Call with functionName(value), not functionName(parameterName: value).
- Useful for cleaner calls when label adds no clarity.

Full Transcript

This visual execution shows how to define a Swift function that omits argument labels by using an underscore before the parameter name. The function greet is defined with _ name: String, so when calling greet, you just pass the argument without a label, like greet("Alice"). The execution table traces defining the function, calling it with "Alice", receiving the argument, printing the greeting, and ending the function. The variable tracker shows the parameter 'name' changes from undefined to "Alice" after the call. Key moments clarify why the label is omitted and what happens if you try to use a label. The quiz tests understanding of parameter values, print timing, and how calls change if _ is removed. This helps beginners see step-by-step how omitting argument labels works in Swift.

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