Enumerations trong Swift

enum Direction {
    case north
    case south
    case east
    case west
}
 
// Hoặc trên một dòng
enum Color { case red, green, blue }
 
var direction = Direction.north
direction = .south  // Type inference

enum Day {
    case monday, tuesday, wednesday, thursday, friday, saturday, sunday
}
 
func describe(_ day: Day) -> String {
    switch day {
    case .saturday, .sunday:
        return "Weekend!"
    case .friday:
        return "TGIF!"
    default:
        return "Weekday"
    }
}

enum StatusCode: Int {
    case ok = 200
    case created = 201
    case badRequest = 400
    case notFound = 404
}
 
let code = StatusCode.notFound
print(code.rawValue)  // 404
 
// Từ raw value
if let status = StatusCode(rawValue: 200) {
    print(status)  // ok
}

enum Planet: String {
    case mercury, venus, earth, mars
}
 
print(Planet.earth.rawValue)  // "earth"
 
enum Currency: String {
    case usd = "USD"
    case eur = "EUR"
    case vnd = "VND"
}

enum Result {
    case success(data: String)
    case failure(error: Error)
}
 
let result = Result.success(data: "Hello")
 
switch result {
case .success(let data):
    print("Got: \(data)")
case .failure(let error):
    print("Error: \(error)")
}

enum Temperature {
    case celsius(Double)
    case fahrenheit(Double)
    
    var celsius: Double {
        switch self {
        case .celsius(let c): return c
        case .fahrenheit(let f): return (f - 32) * 5/9
        }
    }
    
    func description() -> String {
        return "\(celsius)°C"
    }
}

enum Weekday: Int {
    case monday = 1, tuesday, wednesday, thursday, friday, saturday, sunday
    
    var isWeekend: Bool {
        self == .saturday || self == .sunday
    }
    
    var shortName: String {
        String(String(describing: self).prefix(3).uppercased())
    }
}

enum Beverage: CaseIterable {
    case coffee, tea, juice
}
 
// Lấy tất cả cases
for drink in Beverage.allCases {
    print(drink)
}
 
print(Beverage.allCases.count)  // 3

indirect enum ArithmeticExpr {
    case number(Int)
    case addition(ArithmeticExpr, ArithmeticExpr)
    case multiplication(ArithmeticExpr, ArithmeticExpr)
}
 
func evaluate(_ expr: ArithmeticExpr) -> Int {
    switch expr {
    case .number(let n): return n
    case .addition(let a, let b): return evaluate(a) + evaluate(b)
    case .multiplication(let a, let b): return evaluate(a) * evaluate(b)
    }
}
 
let expr = ArithmeticExpr.multiplication(
    .addition(.number(5), .number(3)),
    .number(2)
)
print(evaluate(expr))  // 16