𝗦𝘄𝗶𝗳𝘁 𝗘𝗻𝘂𝗺𝗲𝗿𝗮𝘁𝗶𝗼𝗻𝘀: 𝗙𝗿𝗼𝗺 𝗕𝗮𝘀𝗶𝗰𝘀 𝘁𝗼 𝗔𝗱𝘃𝗮𝗻𝗰𝗲𝗱 𝗦𝘄𝗶𝗳𝘁 𝟲 𝗖𝗼𝗻𝗰𝗲𝗽𝘁𝘀

Swift’s enumerations (enums) are a powerful feature that allows you to group related values into a single, type-safe construct. Whether you’re an iOS beginner or an experienced developer, enums help you write clearer, safer, and more maintainable code. In this post, we’ll start with the basics of Swift enums and then explore some advanced concepts introduced in Swift 6.

1. The Basics of Swift Enumerations

What Is an Enumeration?

An enumeration defines a common type for a group of related values. Enums let you:

• Represent a fixed set of cases (e.g., days of the week).
• Provide computed properties.
• Store associated values (extra data for each case).
• Use raw values (such as Int or String).

Syntax Example:

enum SomeEnumerationName {
    // List of cases
}

Diagram:

+----------------------+
         |   SomeEnumeration    |
         +----------------------+
         |  Case1               |
         |  Case2               |
         |  Case3               |
         +----------------------+

Why Use Enums Over Structs?

Enums make your code easier to understand and safer by ensuring that only a limited set of values can be used. They work exceptionally well with switch statements to handle every possible case.

Example: Car Brand Option

enum CarBrandOption {
    case ford, toyota, honda

    var title: String {
        switch self {
        case .ford:   return "Ford"
        case .toyota: return "Toyota"
        case .honda:  return "Honda"
        }
    }
}

struct CarModel {
    let brand: CarBrandOption
    let modelName: String
}

let car1 = CarModel(brand: .ford, modelName: "EcoSport")
print(car1.brand.title) // Prints "Ford"

Diagram:

+---------------------+
        | CarBrandOption Enum |
        +---------------------+
        | ford                |
        | toyota              |
        | honda               |
        +---------------------+
               │
               ▼
       +-------------------+
       | CarModel Struct   |
       +-------------------+
       | brand: CarBrand   |
       | modelName: String |
       +-------------------+

Using Enums with Switch Statements

Switch statements ensure every possible enum case is handled, reducing errors.

Example: Compass Directions

enum CompassPoint {
    case north, south, east, west
}

let direction = CompassPoint.north

switch direction {
case .north:
    print("Lots of planets have a north direction!")
case .south:
    print("Watch out for Penguins.")
case .east:
    print("Sun rises here.")
case .west:
    print("Sun sets here.")
}

Diagram:

+----------------+
         | CompassPoint   |
         +----------------+
         | north          |
         | south          |
         | east           |
         | west           |
         +----------------+
                │
                ▼
         +----------------------+
         |    switch(direction) |
         +----------------------+
         |  case .north: ...    |
         |  case .south: ...    |
         |  case .east: ...     |
         |  case .west: ...     |
         +----------------------+

Enumerations with Associated and Raw Values

Enums can hold extra information (associated values) or a constant value (raw values) for each case.

Associated Values — Example: BarCode

enum BarCode {
    case upc(Int, Int, Int, Int)
    case qrCode(String)
}

var productBarCode = BarCode.upc(8, 85909, 51552, 3)
print(productBarCode)  // upc(8, 85909, 51552, 3)

productBarCode = .qrCode("ABBABABABABABAJhj")
print(productBarCode)  // qrCode("ABBABABABABABAJhj")

Raw Values — Example: Planet Enum

enum Planet: Int {
    case mercury = 1, venus, earth, mars, jupiter, saturn, uranus, neptune
}

if let earth = Planet(rawValue: 3) {
    print("Earth is the third planet from the sun")
}

Diagrams:

Get Bala Baskar Bollisetty’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

Associated Values:

+----------------------+
           |      BarCode         |
           +----------------------+
           | upc(Int,Int,Int,Int) | 
           | qrCode(String)       |
           +----------------------+

Raw Values:

+-------------------------+
         |      Planet Enum        |
         +-------------------------+
         | mercury = 1             |
         | venus   = 2             |
         | earth   = 3             |
         | mars    = 4             |
         | ...                     |
         +-------------------------+

Iterating Over Enum Cases

Using the CaseIterable protocol lets you iterate over all cases.

Example: Beverage Enum

enum Beverage: CaseIterable {
    case coffee, tea, juice, coolDrink
}

for beverage in Beverage.allCases {
    print(beverage)
}

Diagram:

+-----------------+
         |   Beverage      |
         +-----------------+
         | coffee          |
         | tea             |
         | juice           |
         | coolDrink       |
         +-----------------+
                │
                ▼
         [Loop prints each beverage]

2. Advanced Swift 6 Enumeration Concepts

Swift 6 builds on these fundamentals by introducing advanced features that make enums even more powerful and expressive.

Advanced Pattern Matching

Swift 6 improves pattern matching, making it easier to extract associated values from complex enums.

Example: Handling a Complex Network Response

enum NetworkResponse {
    case success(data: [String: Any])
    case failure(error: (code: Int, message: String))
}

let response: NetworkResponse = .failure(error: (code: 404, message: "Not Found"))

switch response {
case .success(let data):
    print("Data received: \(data)")
case .failure(let error) where error.code == 404:
    print("Error 404: \(error.message)")
case .failure(let error):
    print("Error \(error.code): \(error.message)")
}

Diagram:

+-----------------------+
          |  NetworkResponse Enum |
          +-----------------------+
          | success(data: Dict)   |
          | failure(error: Tuple) |
          +-----------------------+
                  │
                  ▼
         +----------------------+
         |    switch(response)  |
         +----------------------+
         |  case .success: ...  |
         |  case .failure: ...  |
         +----------------------+

Frozen Enums & Exhaustiveness Improvements

In Swift 6, non-public enums are “frozen” by default. This means:

• The compiler knows no new cases will be added.
• Every switch statement must handle all possible cases, enhancing safety and enabling performance optimizations.

Example: Frozen Weekday Enum

enum Weekday: CaseIterable {
    case monday, tuesday, wednesday, thursday, friday, saturday, sunday
}

let today: Weekday = .wednesday

switch today {
case .monday:
    print("Start of the work week!")
case .tuesday:
    print("It's Tuesday.")
case .wednesday:
    print("Midweek already!")
case .thursday:
    print("Almost there...")
case .friday:
    print("Weekend is near!")
case .saturday, .sunday:
    print("Enjoy your weekend!")
}

Diagram:

+-------------------+
         |     Weekday       |
         +-------------------+
         | monday            |
         | tuesday           |
         | wednesday         |
         | thursday          |
         | friday            |
         | saturday          |
         | sunday            |
         +-------------------+
                  │  (Frozen by default)
                  ▼
         +-----------------------+
         |   Exhaustive switch   |
         +-----------------------+

Enum Macros for Boilerplate Reduction

Swift 6 introduces an early version of macros — a metaprogramming tool that reduces boilerplate. With macros, you can auto-generate common functionality such as a description for each enum case.

Example: Auto-Generating a Description

// Hypothetical macro usage (syntax may evolve)
@EnumDescription
enum Status {
    case success
    case error(code: Int)
}

// The macro auto-generates a description property:
let currentStatus = Status.error(code: 500)
print(currentStatus.description)
// Expected output: "error (500)"

Diagram:

+-----------------------+
         |       Status Enum     |
         +-----------------------+
         | success               |
         | error(code: Int)      |
         +-----------------------+
                  │
                  ▼
         +-------------------------+
         |   @EnumDescription Macro|
         |   (Auto-generates code) |
         +-------------------------+
                  │
                  ▼
         +-------------------------+
         |  description Property   |
         +-------------------------+

3. Conclusion

Swift enums help you manage related values in a concise, type-safe way — making your code both clear and robust. Starting from basic usage with switch statements, associated values, and raw values, you can now explore advanced Swift 6 features such as improved pattern matching, frozen enums for exhaustive safety, and macros for reducing boilerplate. Whether you’re a beginner or an experienced iOS developer, these techniques empower you to write cleaner and more efficient code.

Happy coding!