枚举 #

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

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

let direction = Direction.north
print(direction)

var currentDirection = Direction.north
currentDirection = .south

switch currentDirection {
case .north:
    print("向北")
case .south:
    print("向南")
case .east:
    print("向东")
case .west:
    print("向西")
}

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

var productBarcode = Barcode.upc(8, 85909, 51226, 3)
productBarcode = .qrCode("ABCDEFGHIJKLMNOP")

switch productBarcode {
case .upc(let numberSystem, let manufacturer, let product, let check):
    print("UPC: \(numberSystem)-\(manufacturer)-\(product)-\(check)")
case .qrCode(let productCode):
    print("QR: \(productCode)")
}

enum Response {
    case success(Data)
    case failure(Error)
}

func handle(response: Response) {
    switch response {
    case .success(let data):
        print("成功: \(data)")
    case .failure(let error):
        print("失败: \(error)")
    }
}

enum NetworkResponse {
    case loading
    case success(User)
    case error(String)
}

func handle(response: NetworkResponse) {
    switch response {
    case .loading:
        print("加载中...")
    case .success(let user):
        print("用户: \(user.name)")
    case .error(let message):
        print("错误: \(message)")
    }
}

enum ASCIIControlCharacter: Character {
    case tab = "\t"
    case lineFeed = "\n"
    case carriageReturn = "\r"
}

print(ASCIIControlCharacter.tab.rawValue)

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

print(Planet.earth.rawValue)

if let planet = Planet(rawValue: 3) {
    print(planet)
}

enum Direction: String {
    case north = "北"
    case south = "南"
    case east = "东"
    case west = "西"
}

print(Direction.north.rawValue)

if let direction = Direction(rawValue: "南") {
    print(direction)
}

enum ArithmeticExpression {
    case number(Int)
    indirect case addition(ArithmeticExpression, ArithmeticExpression)
    indirect case multiplication(ArithmeticExpression, ArithmeticExpression)
}

indirect enum Expr {
    case number(Int)
    case add(Expr, Expr)
    case multiply(Expr, Expr)
}

func evaluate(_ expression: Expr) -> Int {
    switch expression {
    case .number(let value):
        return value
    case .add(let left, let right):
        return evaluate(left) + evaluate(right)
    case .multiply(let left, let right):
        return evaluate(left) * evaluate(right)
    }
}

let expr = Expr.multiply(
    Expr.add(Expr.number(2), Expr.number(3)),
    Expr.number(4)
)
print(evaluate(expr))

enum Direction {
    case north, south, east, west
    
    func opposite() -> Direction {
        switch self {
        case .north: return .south
        case .south: return .north
        case .east: return .west
        case .west: return .east
        }
    }
    
    mutating func turnRight() {
        switch self {
        case .north: self = .east
        case .south: self = .west
        case .east: self = .south
        case .west: self = .north
        }
    }
}

var direction = Direction.north
print(direction.opposite())
direction.turnRight()
print(direction)

enum Season {
    case spring, summer, autumn, winter
    
    var months: [String] {
        switch self {
        case .spring: return ["3月", "4月", "5月"]
        case .summer: return ["6月", "7月", "8月"]
        case .autumn: return ["9月", "10月", "11月"]
        case .winter: return ["12月", "1月", "2月"]
        }
    }
    
    var temperature: String {
        switch self {
        case .spring: return "温暖"
        case .summer: return "炎热"
        case .autumn: return "凉爽"
        case .winter: return "寒冷"
        }
    }
}

print(Season.summer.months)
print(Season.winter.temperature)

enum Direction: CaseIterable {
    case north, south, east, west
}

print(Direction.allCases.count)

for direction in Direction.allCases {
    print(direction)
}

enum Status: String, Codable {
    case pending = "pending"
    case approved = "approved"
    case rejected = "rejected"
}

struct Task: Codable {
    let id: Int
    let status: Status
}

let json = """
{"id": 1, "status": "approved"}
"""

let task = try JSONDecoder().decode(Task.self, from: json.data(using: .utf8)!)
print(task.status)

enum LoadingState {
    case idle
    case loading
    case loaded(Data)
    case error(Error)
    
    var isLoading: Bool {
        if case .loading = self { return true }
        return false
    }
    
    var data: Data? {
        if case .loaded(let data) = self { return data }
        return nil
    }
}

class ViewModel {
    var state: LoadingState = .idle
    
    func load() {
        state = .loading
        
        DispatchQueue.global().async {
            Thread.sleep(forTimeInterval: 1)
            
            DispatchQueue.main.async {
                self.state = .loaded(Data())
            }
        }
    }
}

enum Result<Success, Failure: Error> {
    case success(Success)
    case failure(Failure)
    
    func map<T>(_ transform: (Success) -> T) -> Result<T, Failure> {
        switch self {
        case .success(let value):
            return .success(transform(value))
        case .failure(let error):
            return .failure(error)
        }
    }
    
    func get() throws -> Success {
        switch self {
        case .success(let value):
            return value
        case .failure(let error):
            throw error
        }
    }
}

enum Environment {
    case development
    case staging
    case production
    
    var baseURL: String {
        switch self {
        case .development:
            return "http://localhost:3000"
        case .staging:
            return "https://staging.api.example.com"
        case .production:
            return "https://api.example.com"
        }
    }
    
    var apiKey: String {
        switch self {
        case .development:
            return "dev_key"
        case .staging:
            return "staging_key"
        case .production:
            return "prod_key"
        }
    }
}