Swift: Swift列挙型とパターンマッチングチュートリアル：基本の関連値から再帰的列挙型まで

// Inelegant approach: multiple optional variables to represent state
var data: NewsResponse? = nil
var error: Error? = nil
var isLoading = false

enum NetworkResult<T> {
    case success(T)
    case failure(Error)
    case loading
}

// ============================================
// HTTP status code enum using raw values
// ============================================
enum HTTPStatus: Int {
    case ok = 200
    case created = 201
    case badRequest = 400
    case unauthorized = 401
    case notFound = 404
    case serverError = 500
}
let status = HTTPStatus.notFound
print("Code: \(status.rawValue)")
print("Name: \(status)")
// Create from raw value
let parsed = HTTPStatus(rawValue: 200)
print("Parsed: \(parsed ?? .serverError)")

// ============================================
// Custom enum method: determine status category
// ============================================
enum HTTPStatus: Int {
    case ok = 200
    case created = 201
    case badRequest = 400
    case unauthorized = 401
    case notFound = 404
    case serverError = 500
    var isSuccess: Bool {
        rawValue >= 200 && rawValue < 300
    }
    var description: String {
        switch self {
        case .ok: return "OK"
        case .created: return "Created"
        case .badRequest: return "Bad Request"
        case .unauthorized: return "Unauthorized"
        case .notFound: return "Not Found"
        case .serverError: return "Internal Server Error"
        }
    }
}
let code = HTTPStatus.ok
print("\(code.rawValue) \(code.description) - Success: \(code.isSuccess)")

// ============================================
// Associated value enum for handling API responses
// ============================================
enum NetworkResult<T> {
    case success(T)
    case failure(String)
    case loading
}
func handleResponse<T>(_ result: NetworkResult<T>) {
    switch result {
    case .success(let data):
        print("Successfully received data: \(data)")
    case .failure(let error):
        print("Request failed: \(error)")
    case .loading:
        print("Loading...")
    }
}
handleResponse(NetworkResult.success("User Info"))
handleResponse(NetworkResult.failure("Network connection timed out"))
handleResponse(NetworkResult.loading)

// ============================================
// Concise usage of if-case and guard-case
// ============================================
enum Measurement {
    case weight(Double)
    case height(Double)
    case count(Int)
}
let record = Measurement.weight(75.5)
// if-case: only care about one case
if case .weight(let kg) = record, kg > 70 {
    print("Weight exceeds 70kg: \(kg)")
}
// guard-case: early exit
func process(_ m: Measurement) {
    guard case .count(let n) = m else {
        print("Not a count type")
        return
    }
    print("Count is \(n)")
}
process(.weight(65))
process(.count(42))

// ============================================
// Recursive enum: math expression tree
// ============================================
indirect enum ArithmeticExpression {
    case number(Int)
    case addition(ArithmeticExpression, ArithmeticExpression)
    case multiplication(ArithmeticExpression, ArithmeticExpression)
}
func evaluate(_ expr: ArithmeticExpression) -> Int {
    switch expr {
    case .number(let value):
        return value
    case .addition(let left, let right):
        return evaluate(left) + evaluate(right)
    case .multiplication(let left, let right):
        return evaluate(left) * evaluate(right)
    }
}
// Build the expression (3 + 5) * 2
let three = ArithmeticExpression.number(3)
let five = ArithmeticExpression.number(5)
let sum = ArithmeticExpression.addition(three, five)
let product = ArithmeticExpression.multiplication(sum, .number(2))
print("(3 + 5) * 2 = \(evaluate(product))")

// ============================================
// Full example: E-commerce order state machine
// Features: order state transitions + data processing
// ============================================
import Foundation
// 1. Order status enum (with associated values)
enum OrderStatus {
    case pending          // Pending payment
    case paid(Date)       // Paid (with payment time)
    case shipped(trackingNumber: String)  // Shipped (with tracking number)
    case delivered(Date)  // Delivered (with receipt time)
    case cancelled(reason: String)  // Cancelled (with reason)
    var description: String {
        switch self {
        case .pending: return "Pending"
        case .paid(let date): return "Paid (\(date.formatted()))"
        case .shipped(let tracking): return "Shipped (Tracking: \(tracking))"
        case .delivered(let date): return "Delivered (\(date.formatted()))"
        case .cancelled(let reason): return "Cancelled: \(reason)"
        }
    }
    var isFinalState: Bool {
        if case .delivered = self { return true }
        if case .cancelled = self { return true }
        return false
    }
}
// 2. Usage example
let now = Date()
let formatter = DateFormatter()
formatter.dateFormat = "yyyy-MM-dd"
let statuses: [OrderStatus] = [
    .pending,
    .paid(now),
    .shipped(trackingNumber: "SF1234567890"),
    .delivered(now),
    .cancelled(reason: "Cancelled by user")
]
for status in statuses {
    let final = status.isFinalState ? " (Final)" : ""
    print("\(status.description)\(final)")
}