Why Enum with switch pattern matching in Swift? - Purpose & Use Cases

The Big Idea

What if you could handle many different cases in your code without messy if-else chains and mistakes?

The Scenario

Imagine you have different types of messages to handle in your app: text, image, or video. Without enums and switch pattern matching, you might write many if-else checks scattered everywhere to figure out what kind of message you have.

The Problem

This manual way is slow and confusing. You might forget a case or write repeated code. It's easy to make mistakes and hard to add new message types later.

The Solution

Enums with switch pattern matching let you group all message types in one place. The switch checks each case clearly and safely. It forces you to handle every type, making your code neat and error-free.

Before vs After

✗ Before

if messageType == "text" {
  // handle text
} else if messageType == "image" {
  // handle image
} else if messageType == "video" {
  // handle video
}

✓ After

enum Message {
  case text(String)
  case image(URL)
  case video(URL)
}
switch message {
case .text(let content):
  // handle text
case .image(let url):
  // handle image
case .video(let url):
  // handle video
}

What It Enables

You can write clear, safe, and easy-to-maintain code that handles many related cases without confusion.

Real Life Example

In a chat app, you can use enums with switch pattern matching to handle different message types like text, images, or videos, making your code simple and reliable.

Key Takeaways

Manual checks get messy and error-prone.

Enums group related cases clearly.

Switch pattern matching handles all cases safely and cleanly.