설계 정전 3권 정독 — Parnas · Ousterhout · Tar Pit

// ⚠️ 핵심: 이 두 개를 "모든 모듈이 직접" 읽고 쓴다.
var core: [UInt32] = []      // 문자를 한 워드에 4개씩 packing해서 저장
var lineIndex: [Int] = []    // 각 줄의 시작 주소

enum Input {                             // 모듈 1
    static func read(_ path: String) {
        // 파일을 읽어 core에 4개씩 packing하고 lineIndex를 채운다
    }
}

enum CircularShift {                     // 모듈 2
    static func setup() {
        for line in lineIndex.indices {
            let start = lineIndex[line]
            let word  = core[start / 4]  // ← "4개 packing" 규칙을 여기서도 안다
            let byte  = (word >> 24) & 0xFF
            _ = byte
        }
    }
}

enum Alphabetizing {                     // 모듈 3
    static func run() {
        // 정렬하려면 문자를 비교해야 한다 → core 포맷을 또 안다
    }
}

enum Output {                            // 모듈 4
    static func print() {
        // 출력하려면 문자를 꺼내야 한다 → core 포맷을 또 안다
    }
}

// 모듈 1: Line Storage — 저장 방식을 혼자만 안다 (이 모듈의 "비밀")
enum LineStorage {
    private static var core: [UInt32] = []      // 바깥에서 볼 수 없다
    private static var lineIndex: [Int] = []

    static func char(_ r: Int, _ w: Int, _ c: Int) -> UInt8 { /* r번째 줄, w번째 단어, c번째 문자 */ 0 }
    static func setChar(_ r: Int, _ w: Int, _ c: Int, _ d: UInt8) { }
    static func words(_ r: Int) -> Int { 0 }     // r번째 줄의 단어 수
    static func lines() -> Int { 0 }
    static func delLine(_ r: Int) { }
    static func delWord(_ r: Int, _ w: Int) { }
}

// 모듈 3: Circular Shifter — 시프트를 미리 만드는지 그때그때 계산하는지를 감춘다
enum CircularShifter {
    static func setup() { }                                     // 다른 함수보다 먼저 호출
    static func char(_ l: Int, _ w: Int, _ c: Int) -> UInt8 { 0 }  // l번째 시프트의 문자
}

// 모듈 4: Alphabetizer — 한 번에 다 정렬하는지 필요할 때만 하는지를 감춘다
enum Alphabetizer {
    static func alph() { }                       // 다른 함수보다 먼저 호출
    static func ith(_ i: Int) -> Int { 0 }       // i번째로 오는 시프트의 인덱스
}

// Input 안
core[i / 4] |= UInt32(byte) << (24 - 8 * (i % 4))   // → core[i] = UInt32(byte)

// CircularShift 안
let byte = (core[start / 4] >> 24) & 0xFF           // → let byte = core[start]

// Alphabetizing 안
let byte = (core[pos / 4] >> (24 - 8 * (pos % 4)))  // → let byte = core[pos]

// Output 안
let byte = (core[pos / 4] >> (24 - 8 * (pos % 4)))  // → let byte = core[pos]
//  ↑ 네 번 고친다. 한 군데를 빠뜨리면 조용히 깨진다.

enum LineStorage {
    // 바뀌는 건 이 두 함수의 "안"뿐이다
    static func char(_ r: Int, _ w: Int, _ c: Int) -> UInt8 {
        let pos = offset(r, w, c)
     // return UInt8((core[pos / 4] >> (24 - 8 * (pos % 4))) & 0xFF)   // 이전
        return UInt8(core[pos])                                          // 이후
    }
}

// Circular Shifter / Alphabetizer / Output — 수정 0줄
let ch = LineStorage.char(r, w, c)

// ❌ 원래 명세 — 순서까지 약속해 버렸다
//   (1) i < j 이면 i번 줄의 시프트들이 j번 줄보다 앞에 온다
//   (2) 각 줄의 첫 시프트는 원본, 두 번째는 한 단어 회전...
enum CircularShifter {
    static func setup()
    static func char(_ l: Int, _ w: Int, _ c: Int) -> UInt8
}

// ✅ 필요한 만큼만 말했다면
//   (1) 정의상 존재해야 할 시프트가 표에 전부 있다
//   (2) 어떤 것도 두 번 들어가지 않는다
//   (3) 시프트로부터 원본 줄을 알아내는 함수가 있다
enum CircularShifter2 {
    static func setup()
    static func char(_ l: Int, _ w: Int, _ c: Int) -> UInt8
    static func originalLine(_ l: Int) -> Int      // ← 순서 약속 대신 이것
}

final class UserFetcher {
    private let session: URLSession
    private let decoder: JSONDecoder
    private let baseURL: URL
    private let retryPolicy: RetryPolicy
    private let cachePolicy: URLRequest.CachePolicy

    // 쓰려면 이 5개를 다 이해하고 골라야 한다
    init(session: URLSession, decoder: JSONDecoder, baseURL: URL,
         retryPolicy: RetryPolicy, cachePolicy: URLRequest.CachePolicy) { ... }

    // 그런데 하는 일은 URLSession 호출 한 번
    func fetch(_ id: String) async throws -> Data { ... }
}

// 호출부: 결국 내가 다 알아야 한다
let fetcher = UserFetcher(session: .shared, decoder: JSONDecoder(),
                          baseURL: URL(string: "https://api.example.com")!,
                          retryPolicy: .exponential(max: 3),
                          cachePolicy: .reloadIgnoringLocalCacheData)
let data = try await fetcher.fetch("42")
let user = try JSONDecoder().decode(User.self, from: data)   // 디코딩도 내 몫

enum UserAPI {
    /// 사용자를 가져온다. 재시도·캐시·디코딩·에러 변환은 안에서 처리한다.
    static func user(id: String) async throws -> User { ... }
}

// 호출부
let user = try await UserAPI.user(id: "42")

final class DocumentReader {   // 앱 시작할 때 동작
    func read(_ url: URL) -> Document {
        // 헤더 16바이트, 버전은 4~8바이트, 본문은 리틀엔디안...
    }
}

final class DocumentWriter {   // 앱 종료할 때 동작
    func write(_ doc: Document, to url: URL) {
        // 헤더 16바이트, 버전은 4~8바이트, 본문은 리틀엔디안...
        // ↑ 같은 지식이 여기 또 있다. 포맷이 바뀌면 두 군데를 고쳐야 한다
    }
}

enum DocumentFormat {          // "이 포맷을 안다"는 책임 하나
    static func decode(_ data: Data) throws -> Document { ... }
    static func encode(_ doc: Document) -> Data { ... }
    // 헤더 오프셋·엔디안 규칙은 이 안에만 있다
}

// ❌ 복잡도를 위로 민다 — "몇 초가 맞는지는 네가 정해"
struct Transport {
    let retryInterval: TimeInterval      // 사용자가 이 값을 어떻게 알지?
}

// ✅ 복잡도를 아래로 내린다 — 성공한 요청의 응답 시간을 재서 스스로 정한다
struct Transport {
    private var rtt = MovingAverage()
    private var retryInterval: TimeInterval { rtt.value * 2 }
    // 덤: 네트워크 상황이 바뀌면 자동으로 따라간다. 고정 파라미터는 금방 낡는다.
}

extension String {
    func substring(from: Int, to: Int) throws -> String {
        guard from >= 0, to <= count, from <= to else { throw StringError.outOfRange }
        ...
    }
}

// 호출부 — 매번 이런다
let preview: String
if text.count > 100 {
    preview = try text.substring(from: 0, to: 100)
} else {
    preview = text
}

extension String {
    /// 범위를 벗어나면 문자열 경계로 자른다. 실패하지 않는다.
    func substring(from: Int, to: Int) -> String {
        let lo = max(0, min(from, count))
        let hi = max(lo, min(to, count))
        ...
    }
}

// 호출부
let preview = text.substring(from: 0, to: 100)   // 짧아도 그냥 된다

// count를 1 증가시킨다
count += 1

/// 사용자를 가져온다
func fetchUser(id: String) async throws -> User

/// 사용자를 가져온다.
///
/// 네트워크 실패 시 최대 3회까지 지수 백오프로 재시도한다 — 호출자는 재시도를 신경 쓰지 않아도 된다.
/// 5분 이내에 같은 id로 호출하면 캐시된 값을 돌려준다. 강제로 새로 받으려면 `refreshUser(id:)`.
/// 취소되면 `CancellationError`를 던진다. 그 외 에러는 전부 `APIError`로 변환된다.
func fetchUser(id: String) async throws -> User

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

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 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
    }
}