09 · 열거형과 패턴 매칭

enum OneCase { case only }
enum Direction { case north, south, east, west }
print(MemoryLayout<OneCase>.size, MemoryLayout<OneCase>.stride)      // 0 1
print(MemoryLayout<Direction>.size, MemoryLayout<Direction>.stride)  // 1 1

enum Maybe { case a(String); case b }
print(MemoryLayout<String>.size, MemoryLayout<Maybe>.size)          // 16 16 — 오버헤드 0

enum MaybeInt { case a(Int); case b }
print(MemoryLayout<Int>.size, MemoryLayout<MaybeInt>.size)          // 8  9  — 태그 추가

enum MultiPayload { case a(Int); case b(Double) }
print(MemoryLayout<MultiPayload>.size, MemoryLayout<MultiPayload>.stride) // 9 16

indirect enum Expr { case number(Int); case add(Expr, Expr); case negate(Expr) }
print(MemoryLayout<Expr>.size)   // 8 — 포인터 하나

// case 단위 indirect: 재귀 아닌 케이스는 인라인 유지
enum ExprPartial {
    case number(Int)
    indirect case add(ExprPartial, ExprPartial)
    indirect case negate(ExprPartial)
}
print(MemoryLayout<ExprPartial>.size)  // 9

enum Expr {
    case number(Int)
    case add(Expr, Expr)   // indirect 없음
}
// swiftc 실행 결과:
// error: recursive enum 'Expr' is not marked 'indirect'
// note: cycle beginning here: (Expr, Expr) -> (.0: Expr)

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

func evaluate(_ e: Expr) -> Int {
    switch e {
    case .number(let n):
        return n
    case .add(let l, let r):
        return evaluate(l) + evaluate(r)   // 힙에 박싱된 두 서브트리를 각각 역참조
    case .negate(let e):
        return -evaluate(e)
    }
}

// (3 + (-4))
let tree = Expr.add(.number(3), .negate(.number(4)))
print(evaluate(tree))  // -1

// ⚠️ 노드마다 힙 할당 1회 + ARC. 성능이 중요한 대량 트리(파서 AST 등)라면
//    노드 수만큼 힙 할당이 늘어난다는 걸 감안해야 한다.

// ❌ Int payload — 케이스 하나 늘리는 게 진짜로 1바이트+패딩을 늘린다
enum CountResult { case value(Int); case unavailable }
print(MemoryLayout<CountResult>.stride)  // 16 (Int 8B + 태그 1B → 정렬 패딩)

// ✅ 참조/String류 payload — "없음" 케이스가 사실상 공짜
enum TextResult { case value(String); case unavailable }
print(MemoryLayout<TextResult>.stride)  // 16 (String과 완전히 동일)

// 10,000개 배열이면 CountResult든 TextResult든 stride는 같지만,
// "Int만 담는 옵셔널 스러운 케이스"를 직접 설계할 때는
// 태그가 별도로 붙는지 MemoryLayout으로 먼저 재보는 습관이 감보다 정확하다.

// Framework.swift
public enum Status {            // non-frozen(기본값) — 나중에 케이스가 늘 수 있다
    case active
    case inactive
}

@frozen
public enum FixedStatus {       // frozen — 케이스 추가 자체를 금지하는 약속
    case on
    case off
}

// 빌드: swiftc -emit-module -emit-library -module-name Framework \
//              -enable-library-evolution Framework.swift -o libFramework.dylib

import Framework
func describe(_ s: Status) -> String {
    switch s {
    case .active: return "on"
    case .inactive: return "off"
    // @unknown default 없음
    }
}
// swiftc(기본/Swift 5 모드) 결과:
// warning: switch covers known cases, but 'Status' may have additional
//          unknown values; this is an error in the Swift 6 language mode
// note: handle unknown values using "@unknown default"

func describeFixed(_ s: FixedStatus) -> String {
    switch s {
    case .on: return "on"
    case .off: return "off"
    // 경고 없음 — @frozen이라 컴파일러가 케이스 목록을 '영구 확정'으로 신뢰한다
    }
}

// swiftc -swift-version 6 로 같은 코드를 컴파일하면:
// error: switch covers known cases, but 'Status' may have additional unknown values
// -> 경고가 아니라 빌드 실패

import Foundation

func describe(_ status: Status) -> String {
    switch status {
    case .active: return "활성"
    case .inactive: return "비활성"
    @unknown default:
        // 지금 빌드가 모르는 케이스 — 조용히 무시하지 않고 신호를 남긴다
        assertionFailure("Status에 처리하지 않은 새 케이스가 추가됨: \(status)")
        return "알 수 없음"
    }
}

// ✅ 절대 안 늘어날 확신이 있을 때만 (예: 나침반 방향처럼 개념 자체가 고정)
@frozen
public enum CompassDirection { case north, south, east, west }

// ❌ 앞으로 케이스가 늘 가능성이 있는 도메인이면 frozen을 붙이지 않는다
//    (그래야 다음 버전에서 case를 추가해도 클라이언트 ABI가 안 깨진다.
//     대신 클라이언트는 @unknown default를 강제로 마주하게 된다.)
public enum PaymentMethod { case card, cash /* 나중에 .applePay 추가 예정 */ }

enum NetworkEvent {
    case connected(String)
    case failed(code: Int, message: String)
    case idle
}
let events: [NetworkEvent] = [.connected("a"), .idle, .failed(code: 500, message: "x")]

// for case let ... where — 특정 케이스 + 조건
for case .failed(let code, let msg) in events where code >= 500 {
    print("서버 에러:", code, msg)   // 서버 에러: 500 x
}

// 튜플 패턴 + 레인지
let point = (3, 7)
switch point {
case (0, 0): print("origin")
case (-10...10, -10...10): print("근처")   // 여기 매치
default: print("멀리")
}

// 옵셔널 패턴 — nil 아닌 것만
for case let n? in [1, nil, 3, nil, 5] as [Int?] {
    print("값 있음:", n)   // 1, 3, 5만 출력
}

// 중첩 enum 패턴 — 한 번에 파고들기
enum Shape { case circle(radius: Double) }
enum Layer { case shape(Shape) }
if case .shape(.circle(let r)) = Layer.shape(.circle(radius: 5)) {
    print("반지름:", r)   // 5.0
}

// ❌ 나쁜 예 — 케이스 확인과 조건이 중첩되어 "뭘 걸러내는지"가 들여쓰기 속에 묻힌다
for event in events {
    if case .failed(let code, let message) = event {
        if code >= 500 {
            print("서버 에러:", code, message)
        }
    }
}

// ✅ 좋은 예 — 한 줄에 "어떤 케이스"와 "어떤 조건"이 나란히 드러난다
for case .failed(let code, let message) in events where code >= 500 {
    print("서버 에러:", code, message)
}

enum Shape { case circle(radius: Double); case rectangle(w: Double, h: Double) }
enum Layer { case shape(Shape); case group([Layer]) }
let layer = Layer.shape(.circle(radius: 5))

// ❌ 나쁜 예 — 파고드는 단계 수만큼 들여쓰기가 깊어진다
if case .shape(let shape) = layer {
    if case .circle(let r) = shape {
        print("원 반지름:", r)
    }
}

// ✅ 좋은 예 — 몇 단계를 파고들든 패턴 하나로 표현
if case .shape(.circle(let r)) = layer {
    print("원 반지름:", r)
}

let point = (3, 7)

// ❌ 나쁜 예 — 조합이 늘어날수록 조건식이 길어지고 순서에 의존하게 된다
if point.0 == 0 && point.1 == 0 {
    print("origin")
} else if (-10...10).contains(point.0) && (-10...10).contains(point.1) {
    print("근처")
} else {
    print("멀리")
}

// ✅ 좋은 예 — 각 케이스가 독립된 한 줄로 나열되어 경우의 수가 한눈에 보인다
switch point {
case (0, 0): print("origin")
case (-10...10, -10...10): print("근처")
default: print("멀리")
}

struct StatusClass { let range: ClosedRange<Int> }
func ~= (pattern: StatusClass, value: Int) -> Bool {
    pattern.range.contains(value)
}
let success = StatusClass(range: 200...299)
let clientError = StatusClass(range: 400...499)
let serverError = StatusClass(range: 500...599)

func classify(_ code: Int) -> String {
    switch code {
    case success: return "성공"
    case clientError: return "클라이언트 에러"
    case serverError: return "서버 에러"
    default: return "기타(\(code))"
    }
}
print(classify(204), classify(404), classify(503))  // 성공 클라이언트 에러 서버 에러

// ~=는 그냥 연산자라서 switch 밖에서도 직접 호출된다
print(success ~= 250)   // true

// 표준 라이브러리는 Regex<Substring>과 String을 잇는 ~=를 공짜로 주지 않는다(실측 확인).
// 그래서 switch에서 쓰려면 직접 오버로드를 정의해야 한다.
func ~= (regex: Regex<Substring>, value: String) -> Bool {
    value.wholeMatch(of: regex) != nil
}

let inputs = ["hello123", "BAD", "42world"]
for input in inputs {
    switch input {
    case #/^[a-z]+\d+$/#: print("[\(input)] 소문자+숫자")
    case #/^\d+[a-z]+$/#: print("[\(input)] 숫자+소문자")
    default: print("[\(input)] 매치 안 됨")
    }
}
// 출력: hello123 -> 소문자+숫자 / BAD -> 매치 안 됨 / 42world -> 숫자+소문자

enum RetryPolicy { case retry, giveUp, refreshTokenThenRetry }

func policy(for statusCode: Int) -> RetryPolicy {
    switch statusCode {
    case StatusClass(range: 200...299):
        return .giveUp  // 성공이니 재시도할 필요 없음
    case StatusClass(range: 401...401), StatusClass(range: 403...403):
        return .refreshTokenThenRetry
    case StatusClass(range: 500...599):
        return .retry
    default:
        return .giveUp
    }
}

func classifyToken(_ s: String) -> String {
    switch s {
    case #/^\d+$/#:            return "숫자"
    case #/^[a-zA-Z]+$/#:      return "영문자"
    case #/^[a-zA-Z]+\d+$/#:   return "영문+숫자"
    default:                   return "기타"
    }
}
// (앞서 정의한 Regex<Substring> -> String용 ~= 오버로드가 이 switch를 가능하게 한다)