Out of the Tar Pit 정독

final class UploadView {
    var isLoading    = false   //  2
    var hasError     = false   //  4
    var isEditing    = false   //  8
    var isSelected   = false   // 16
    var isOffline    = false   // 32
    var didAuth      = false   // 64
    // ... 여기까지 64가지. 30개면 10억 가지가 넘는다.
    // 테스트에서 확인하는 건 그중 몇 개일까?
}

enum UploadState {
    case idle
    case loading
    case failed(Error)
    case done(URL)
}
final class UploadView {
    var state: UploadState = .idle
}

a := b + 3
c := d + 2
e := f * 4

final class Money {                 // 값인데 객체다
    let amount: Decimal
    let currency: String
}
let a = Money(amount: 100, currency: "KRW")
let b = Money(amount: 100, currency: "KRW")
a === b                             // false — 정체성 비교
a == b                              // 직접 구현해야 한다 (Value Object 기법)
// 논문의 지적: 도메인별 동등성을 직접 만들면
// 그것이 동치관계의 표준 성질(예: 추이성)을 만족한다는 보장이 사라진다.

struct Money2: Equatable {          // ✅ 정체성 개념 자체가 없다
    let amount: Decimal
    let currency: String
}

final class Employee {
    var department: Department?          // 참조 ①
}
final class Department {
    var employees: [Employee] = []       // 참조 ②
}

// 이제 이 둘을 항상 맞춰야 한다 — 한 곳만 고치면 조용히 깨진다
func move(_ e: Employee, to d: Department) {
    e.department?.employees.removeAll { $0 === e }
    e.department = d
    d.employees.append(e)                // 🐞 이 줄을 빠뜨리면?
}

struct Employment: Hashable {            // 본질적 상태: 관계 하나
    let employeeID: EmployeeID
    let departmentID: DepartmentID
}
var employment: Set<Employment> = []

// 두 방향 질문 모두 파생이다 — 저장하지 않는다
func members(of d: DepartmentID) -> [EmployeeID] {
    employment.filter { $0.departmentID == d }.map(\.employeeID)
}
func department(of e: EmployeeID) -> DepartmentID? {
    employment.first { $0.employeeID == e }?.departmentID
}
func move(_ e: EmployeeID, to d: DepartmentID) {
    employment = employment.filter { $0.employeeID != e }
    employment.insert(Employment(employeeID: e, departmentID: d))
}

final class Cart {
    private(set) var items: [Item] = []
    private(set) var total: Int = 0        // ← 파생 가능한데 저장했다
    private(set) var isEmpty: Bool = true  // ← 이것도
    private(set) var discount: Int = 0     // ← 이것도

    func add(_ item: Item) {
        items.append(item)
        total += item.price                // 세 줄을 매번 맞춰 줘야 한다
        isEmpty = false
        discount = computeDiscount()
    }

    func remove(at i: Int) {
        items.remove(at: i)
        total -= items[i].price            // 🐞 이미 지운 뒤에 읽는다
        // 🐞 isEmpty · discount 갱신을 잊었다
    }
}

struct Cart {
    private(set) var items: [Item] = []    // ① 본질적 상태 — 사용자가 넣은 것

    // ② 본질적 로직 — 저장하지 않고 그때그때 만든다
    var total: Int    { items.reduce(0) { $0 + $1.price } }
    var isEmpty: Bool { items.isEmpty }
    var discount: Int { computeDiscount(items) }

    mutating func add(_ item: Item) { items.append(item) }
    mutating func remove(at i: Int) { items.remove(at: i) }
    // 동기화할 게 없으므로 동기화 버그도 없다
}

struct OrderBook {
    private(set) var orders: [OrderID: Order] = [:]

    // 무결성 제약 — 항상 참이어야 하는 불리언 식들
    private static func invariants(_ s: [OrderID: Order]) -> Bool {
        s.values.allSatisfy { $0.total >= 0 }
        && s.values.filter { $0.status == .shipped }.allSatisfy { $0.paidAt != nil }
    }

    // 상태를 바꾸는 유일한 통로 — 모든 변경이 제약의 적용을 받는다
    mutating func apply(_ change: (inout [OrderID: Order]) -> Void) throws {
        var next = orders
        change(&next)
        guard Self.invariants(next) else { throw OrderError.invariantViolated }
        orders = next
    }
}

struct Cart {
    private(set) var items: [Item] = []
    var total: Int { Self.computeTotal(items) }

    // 정답을 만드는 순수 함수 — 캐시의 존재를 모른다
    static func computeTotal(_ items: [Item]) -> Int {
        items.reduce(0) { $0 + $1.price }
    }
}

// ③ 우발적 상태 — 완전히 분리된 계층
final class TotalCache {
    private var memo: [Cart.ID: Int] = [:]

    func total(of cart: Cart) -> Int {
        if let hit = memo[cart.id] { return hit }
        let v = Cart.computeTotal(cart.items)   // ← 항상 같은 정답 함수를 부른다
        memo[cart.id] = v
        return v
    }
    func invalidateAll() { memo.removeAll() }   // 지워도 결과는 같다. 느려질 뿐.
}