1enum Direction: String {
2    case north = "N"
3    case south = "S"
4    case east = "E"
5    case west = "W"
6}
7
8// Create from raw value — returns Optional
9let dir = Direction(rawValue: "N")  // Optional(Direction.north)
10let invalid = Direction(rawValue: "X")  // nil
11
12// Safely unwrap
13if let direction = Direction(rawValue: "S") {
14    print("Got direction: \(direction)")  // Got direction: south
15} else {
16    print("Invalid direction")
17}
18
19// Access the raw value
20let d = Direction.east
21print(d.rawValue)  // "E"

1enum StatusCode: Int {
2    case ok = 200
3    case notFound = 404
4    case serverError = 500
5}
6
7if let status = StatusCode(rawValue: 404) {
8    print(status)  // notFound
9}
10
11// With implicit integer raw values (auto-incrementing from 0)
12enum Planet: Int {
13    case mercury  // 0
14    case venus    // 1
15    case earth    // 2
16    case mars     // 3
17}
18
19let planet = Planet(rawValue: 2)  // Optional(Planet.earth)

1enum Color: String {
2    case red      // rawValue = "red"
3    case green    // rawValue = "green"
4    case blue     // rawValue = "blue"
5}
6
7let color = Color(rawValue: "green")  // Optional(Color.green)
8let invalid = Color(rawValue: "Green")  // nil — case sensitive!

1enum Size: String {
2    case small, medium, large
3}
4
5// 1. if-let binding
6if let size = Size(rawValue: "medium") {
7    applySize(size)
8}
9
10// 2. Guard statement
11func processSize(_ raw: String) {
12    guard let size = Size(rawValue: raw) else {
13        print("Invalid size: \(raw)")
14        return
15    }
16    applySize(size)
17}
18
19// 3. Default value with nil-coalescing
20let size = Size(rawValue: userInput) ?? .medium
21
22// 4. Force unwrap (only when guaranteed)
23let knownSize = Size(rawValue: "large")!  // Crashes if nil
24
25// 5. Switch with optional
26switch Size(rawValue: apiResponse) {
27case .small:
28    print("Small")
29case .medium:
30    print("Medium")
31case .large:
32    print("Large")
33case nil:
34    print("Unknown size")
35}

1enum Fruit: String, CaseIterable {
2    case apple, banana, cherry, date
3}
4
5// List all valid raw values
6let validValues = Fruit.allCases.map { $0.rawValue }
7print(validValues)  // ["apple", "banana", "cherry", "date"]
8
9// Custom lookup with case-insensitive matching
10func fruit(from string: String) -> Fruit? {
11    Fruit.allCases.first { $0.rawValue.lowercased() == string.lowercased() }
12}
13
14fruit(from: "BANANA")  // Optional(Fruit.banana)

1enum Priority: String, Codable {
2    case low, medium, high, critical
3}
4
5struct Task: Codable {
6    let title: String
7    let priority: Priority
8}
9
10// JSON decoding
11let json = """
12{"title": "Fix bug", "priority": "high"}
13""".data(using: .utf8)!
14
15let task = try JSONDecoder().decode(Task.self, from: json)
16print(task.priority)  // high
17
18// Invalid value causes DecodingError
19let badJson = """
20{"title": "Test", "priority": "urgent"}
21""".data(using: .utf8)!
22
23// Throws: DecodingError.dataCorrupted — "urgent" is not a valid Priority

1enum UserRole: String, Codable {
2    case admin = "ADMIN"
3    case editor = "EDITOR"
4    case viewer = "VIEWER"
5    case superAdmin = "SUPER_ADMIN"
6}
7
8let role = UserRole(rawValue: "SUPER_ADMIN")  // Optional(UserRole.superAdmin)
9print(role?.rawValue)  // "SUPER_ADMIN"

1enum NetworkError {
2    case timeout(seconds: Int)
3    case httpError(code: Int, message: String)
4    case unknown
5
6    // Custom initializer from HTTP status code
7    init(statusCode: Int) {
8        switch statusCode {
9        case 408:
10            self = .timeout(seconds: 30)
11        case 400...599:
12            self = .httpError(code: statusCode, message: "HTTP \(statusCode)")
13        default:
14            self = .unknown
15        }
16    }
17}
18
19let error = NetworkError(statusCode: 404)
20// .httpError(code: 404, message: "HTTP 404")