Enum declaration and cases in Swift - Step-by-Step Execution

Concept Flow - Enum declaration and cases

Start

↓

Declare enum with cases

↓

Create variable of enum type

↓

Assign one of the enum cases

↓

Use enum variable in code

↓

End

This flow shows how to declare an enum, create a variable of that enum type, assign a case, and then use it.

Execution Sample

Swift

enum Direction {
    case north
    case south
    case east
    case west
}

var currentDirection = Direction.north

Declares an enum Direction with four cases and assigns the north case to a variable.

Execution Table

Step	Action	Code Line	Variable	Value	Notes
1	Declare enum Direction with cases north, south, east, west	enum Direction {...}	-	-	Enum type created
2	Create variable currentDirection of type Direction	var currentDirection = Direction.north	currentDirection	Direction.north	Variable assigned enum case north
3	Use currentDirection in code (example: print)	print(currentDirection)	currentDirection	north	Outputs 'north' when printed

💡 All enum cases declared and variable assigned successfully

Variable Tracker

Variable	Start	After Step 2	After Step 3
currentDirection	undefined	Direction.north	Direction.north

Key Moments - 2 Insights

Why do we write Direction.north instead of just north when assigning?

Because north is a case inside the Direction enum, we must specify the enum type to avoid confusion. See execution_table step 2 where currentDirection is assigned Direction.north.

Can we assign a value to an enum case directly?

No, enum cases are fixed identifiers. You assign the case itself, not a separate value. This is shown in execution_table step 2 where currentDirection gets assigned the case Direction.north.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of currentDirection after step 2?

A Direction.south

B undefined

C Direction.north

D north

💡 Hint

Check the 'Value' column in execution_table row for step 2.

At which step is the enum Direction declared?

A Step 2

B Step 1

C Step 3

D Step 4

💡 Hint

Look at the 'Action' column in execution_table for the declaration.

If we change currentDirection to Direction.west at step 2, what will be printed at step 3?

A Direction.west

B west

C north

D undefined

💡 Hint

The variable value changes at step 2 and is printed at step 3, see variable_tracker.

Concept Snapshot

enum EnumName {
  case case1
  case case2
  ...
}

Use with: var v = EnumName.case1
Enum cases are fixed named values grouped under one type.

Full Transcript

This example shows how to declare an enum named Direction with four cases: north, south, east, and west. Then, a variable currentDirection is created and assigned the case Direction.north. The execution table traces the steps: first the enum is declared, then the variable is assigned, and finally the variable is used (for example, printed). The variable tracker shows currentDirection starts undefined and becomes Direction.north after assignment. Key moments clarify why we use Direction.north instead of just north and that enum cases are fixed identifiers. The quiz questions test understanding of variable values at each step and the enum declaration step.

Practice

1. What is the purpose of an enum in Swift?

easy

A. To group related values under one name

B. To create a function

C. To declare a variable

D. To write a loop

Solution

1. Step 1: Understand what enums represent

   Enums group related values together to make code clearer and safer.

2. Step 2: Compare options with enum purpose

   Only To group related values under one name correctly describes grouping related values under one name.

3. Final Answer:

   To group related values under one name -> Option A

4. Quick Check:

   Enum purpose = Group related values [OK]

Hint: Enums group related values clearly and safely [OK]

Common Mistakes:

• Confusing enums with functions
• Thinking enums declare variables
• Mixing enums with loops

2. Which of the following is the correct way to declare an enum named Direction with cases north, south, east, and west?

easy

A. enum Direction = { north, south, east, west }

B. enum Direction: north, south, east, west {}

C. enum Direction { case north, south, east, west }

D. enum Direction { north; south; east; west }

Solution

1. Step 1: Recall Swift enum syntax

   Enums use the keyword enum, followed by the name and curly braces containing case declarations separated by commas.

2. Step 2: Check each option's syntax

   enum Direction { case north, south, east, west } uses correct syntax: enum Direction { case north, south, east, west }. Others use invalid syntax.

3. Final Answer:

   enum Direction { case north, south, east, west } -> Option C

4. Quick Check:

   Correct enum syntax = enum Direction { case north, south, east, west } [OK]

Hint: Use 'case' keyword with comma-separated values inside braces [OK]

Common Mistakes:

• Using '=' instead of braces
• Omitting 'case' keyword
• Separating cases with semicolons

3. What will be the output of this Swift code?

enum Light {
    case red, yellow, green
}

let current = Light.red
switch current {
case .red:
    print("Stop")
case .yellow:
    print("Caution")
case .green:
    print("Go")
}

medium

A. No output

B. Go

C. Caution

D. Stop

Solution

1. Step 1: Identify the enum case assigned

   The variable current is assigned Light.red.

2. Step 2: Match the switch case for current

   The switch matches .red and prints "Stop".

3. Final Answer:

   Stop -> Option D

4. Quick Check:

   Light.red triggers "Stop" output [OK]

Hint: Match enum case in switch to get output [OK]

Common Mistakes:

• Confusing enum cases with strings
• Forgetting dot prefix in switch
• Assuming default output

4. Identify the error in this enum declaration:

enum Weather {
    case sunny
    case rainy
    case windy
    case
}

medium

A. Missing case name after 'case' keyword

B. Enum name is invalid

C. Curly braces are missing

D. Enum cases should be strings

Solution

1. Step 1: Review each enum case line

   The last line has case without a case name, which is invalid syntax.

2. Step 2: Confirm other parts are correct

   Enum name and braces are correct; cases do not need to be strings.

3. Final Answer:

   Missing case name after 'case' keyword -> Option A

4. Quick Check:

   Every 'case' must have a name [OK]

Hint: Each 'case' must have a name after it [OK]

Common Mistakes:

• Leaving 'case' empty
• Thinking cases need quotes
• Missing braces around enum

5. You want to create an enum Planet with cases for mercury, venus, and earth. Then, write a function that returns a friendly message for each planet. Which code correctly implements this?

hard

A. enum Planet { mercury, venus, earth }
func message(planet: Planet) -> String {
if planet == mercury { return "Closest to the Sun" }
else if planet == venus { return "Second planet" }
else { return "Our home" }
}

B. enum Planet { case mercury, venus, earth }
func message(for planet: Planet) -> String {
switch planet {
case .mercury: return "Closest to the Sun"
case .venus: return "Second planet"
case .earth: return "Our home"
}
}

C. enum Planet { case mercury, venus, earth }
func message(planet: Planet) -> String {
if planet == mercury { return "Closest to the Sun" }
else if planet == venus { return "Second planet" }
else { return "Our home" }
}

D. enum Planet { case mercury, venus, earth }
func message(for planet: Planet) -> String {
switch planet {
case mercury: return "Closest to the Sun"
case venus: return "Second planet"
case earth: return "Our home"
}
}

Solution

1. Step 1: Check enum declaration syntax

   Options A, C, and D declare enum correctly with case keyword; B misses it, so B is invalid.

2. Step 2: Check function parameter and switch usage

   enum Planet { case mercury, venus, earth } func message(for planet: Planet) -> String { switch planet { case .mercury: return "Closest to the Sun" case .venus: return "Second planet" case .earth: return "Our home" } } uses switch with dot syntax for cases and correct function signature. enum Planet { case mercury, venus, earth } func message(planet: Planet) -> String { if planet == mercury { return "Closest to the Sun" } else if planet == venus { return "Second planet" } else { return "Our home" } } uses if-else without dot syntax (.mercury), causing compile error. enum Planet { case mercury, venus, earth } func message(for planet: Planet) -> String { switch planet { case mercury: return "Closest to the Sun" case venus: return "Second planet" case earth: return "Our home" } } misses dot prefix in switch cases, causing error.

3. Final Answer:

   enum Planet { case mercury, venus, earth } func message(for planet: Planet) -> String { switch planet { case .mercury: return "Closest to the Sun" case .venus: return "Second planet" case .earth: return "Our home" } } -> Option B

4. Quick Check:

   Enum with 'case' and switch with dot cases [OK]

Hint: Use 'case' keyword and dot prefix in switch cases [OK]

Common Mistakes:

• Omitting 'case' keyword in enum
• Missing dot prefix in switch cases
• Using if without dot prefix for enum cases