10 · Escaping / Non-Escaping

// ───── non-escaping — 함수 안에서 다 쓰고 끝난다 ─────
func perform(_ work: () -> Void) {
    work()
}
func measure(_ block: () -> Void) -> TimeInterval {
    let start = CFAbsoluteTimeGetCurrent()
    block()
    return CFAbsoluteTimeGetCurrent() - start
}

// ───── ① 저장 — 프로퍼티나 컬렉션에 담는다 ─────
final class Notifier {
    private var handlers: [() -> Void] = []
    func add(_ h: @escaping () -> Void) { handlers.append(h) }
    func fire() { handlers.forEach { $0() } }
}

// ───── ② 비동기 콜백 ─────
func fetch(_ done: @escaping (Data?) -> Void) {
    URLSession.shared.dataTask(with: url) { data, _, _ in
        done(data)          // 함수는 이미 반환된 뒤에 불린다
    }.resume()
}

// ───── ③ 다른 큐/스레드로 전달 ─────
func runLater(_ block: @escaping () -> Void) {
    DispatchQueue.main.asyncAfter(deadline: .now() + 1, execute: block)
}

// ───── ④ 옵셔널 클로저 — 자동으로 escaping이 된다 ─────
func configure(_ handler: ((Int) -> Void)?) {   // @escaping을 쓸 수 없다(중복)
    self.stored = handler                        // 이미 escaping이라 저장 가능
}
// 왜? Optional로 감싸는 순간 값이 다른 곳에 복사·저장될 수 있어
//     "함수 반환 전에 끝난다"를 컴파일러가 보장할 수 없다.

final class Store {
    var saved: (() -> Void)?

    func take(_ block: () -> Void) {        // non-escaping
        // saved = block
        // ❌ error: assigning non-escaping parameter 'block' to
        //           an @escaping closure
    }

    func takeEscaping(_ block: @escaping () -> Void) {
        saved = block                        // ✅ 계약이 맞다
    }
}

// non-escaping 안에서는 self. 을 생략할 수 있다
func sync(_ block: () -> Void) { block() }
final class VM {
    var count = 0
    func run() {
        sync { count += 1 }                  // ✅ self. 생략 가능 — 캡처가 안전하니까
    }
    func runAsync() {
        DispatchQueue.main.async {
            // count += 1
            // ❌ error: reference to property 'count' in closure requires
            //           explicit use of 'self'
            self.count += 1                  // ✅ 명시해야 한다
        }
    }
}

var counter = 0

// ① 기본(참조 캡처): 변수 자체를 붙잡는다 — 나중 값이 보인다
let byReference = { print(counter) }
counter = 10
byReference()          // 10

// ② 캡처 리스트: 클로저 "생성 시점"의 값을 복사한다
counter = 0
let byValue = { [counter] in print(counter) }
counter = 10
byValue()              // 0  ← 생성 시점 값

// ③ 참조 타입을 캡처 리스트에 넣으면? 포인터가 복사될 뿐이다
final class Box { var v = 0 }
let box = Box()
let captured = { [box] in print(box.v) }   // box 참조를 강하게 복사
box.v = 99
captured()             // 99  ← 같은 객체를 보므로 최신 값

// ④ 여러 개 · 약한 참조 혼합
let handler = { [weak self, box, id = item.id] in
    guard let self else { return }
    self.process(id, box)
}

// ───── before: escaping 콜백 ─────
final class Repo {
    func load(_ done: @escaping (Result<User, Error>) -> Void) {
        api.fetch { [weak self] data in          // 순환 참조 신경 써야 함
            guard let self else { return }
            done(self.parse(data))
        }
    }
}

// ───── after: async — 콜백이 반환값이 된다 ─────
final class Repo {
    func load() async throws -> User {
        let data = try await api.fetch()          // 클로저가 없다
        return parse(data)                        // self. 도 필요 없다
    }
}
// 얻는 것:
//   · 클로저가 없으니 self를 붙잡을 주체가 없다 → 순환 참조 없음
//   · 취소가 구조적으로 전파된다 (Task 취소 → await 지점에서 전파)
//   · 에러가 throws 로 자연스럽게 올라간다 (Result 중첩 불필요)
//   · 호출 순서가 코드 순서와 같다

// 레거시를 감쌀 때
func load() async throws -> User {
    try await withCheckedThrowingContinuation { continuation in
        legacyLoad { result in
            continuation.resume(with: result)     // 정확히 한 번만!
        }
    }
}

# 확인 명령
swiftc -emit-sil Closures.swift | swift demangle | grep -E "partial_apply|alloc_box"

# non-escaping 인 경우
#   %5 = partial_apply [callee_guaranteed] [on_stack] %4(%3)
#                                          ^^^^^^^^^^ 스택에 올렸다
#   dealloc_stack %5

# escaping 인 경우
#   %2 = alloc_box ${ var Int }              ← 힙 박스 할당
#   %6 = partial_apply [callee_guaranteed] %5(%2)
#   strong_retain %6                          ← ARC 등장

# 왜 alloc_box 가 필요한가:
#   캡처한 지역 변수를 클로저가 "변경"할 수 있으면,
#   그 변수는 스택 프레임이 아니라 힙 박스에 살아야 한다.
#   → 그래서 var 캡처 + escaping 조합이 가장 비싸다

// non-escaping 클로저를 escaping을 요구하는 API에 넘겨야 할 때
func parallelMap<T, U>(_ xs: [T], _ transform: (T) -> U) -> [U] {
    var result = [U?](repeating: nil, count: xs.count)

    withoutActuallyEscaping(transform) { escapable in
        // 이 스코프 안에서만 escaping인 척 쓸 수 있다
        DispatchQueue.concurrentPerform(iterations: xs.count) { i in
            result[i] = escapable(xs[i])
        }
        // ⚠️ 이 블록을 벗어나기 전에 모든 사용이 끝나야 한다 — 개발자 책임
    }
    return result.compactMap { $0 }
}

// ❌ 계약을 어기면? 정의되지 않은 동작이다
func bad(_ f: () -> Void) {
    withoutActuallyEscaping(f) { escapable in
        DispatchQueue.global().async { escapable() }   // 💥 스코프를 벗어나서 산다
    }   // 여기서 f의 스택 컨텍스트가 사라지는데 나중에 호출된다
}
// → 02번에서 본 "탈출구" 목록의 하나다. 컴파일러가 증명 못 하는 것을
//   개발자가 대신 보증하는 구조.

// 우리가 쓴 것
func makeCounter() -> () -> Int {
    var count = 0
    return { count += 1; return count }     // count는 자유 변수
}

// 컴파일러가 하는 일 — 개념적 변환 (closure conversion / lambda lifting)
struct __Context {          // 캡처한 자유 변수들을 담는 구조체
    var count: Int
}
func __closureBody(_ ctx: inout __Context) -> Int {
    ctx.count += 1
    return ctx.count
}
// 클로저 값 = (함수 포인터, 컨텍스트 포인터) 쌍

// ★ 여기서 핵심 질문이 나온다:
//   __Context 를 어디에 둘 것인가?
//   · 함수가 반환되기 전에 다 쓴다면 → 스택 (공짜)
//   · 반환 후에도 살아야 한다면      → 힙 (할당 + ARC)
//
//   이 판단이 바로 "이스케이프 분석"이다.

// ── Swift: 타입에 적는다. 컴파일러가 계약 위반을 잡는다 ──
func f(_ cb: () -> Void)            // 반환 전에 끝난다 (계약)
func g(_ cb: @escaping () -> Void)  // 더 살 수 있다 (계약)

// ── Go: 컴파일러가 알아서 판단하고, 물어보면 알려 준다 ──
//   $ go build -gcflags='-m' main.go
//   ./main.go:5:6: can inline f
//   ./main.go:9:10: &x escapes to heap        ← 힙으로 갔다
//   ./main.go:12:9: x does not escape         ← 스택에 남았다

// ── Rust: 수명이 타입의 일부. 어기면 컴파일 에러 ──
//   fn f<'a>(cb: &'a dyn Fn())          // 'a 만큼만 산다
//   fn g(cb: Box<dyn Fn() + 'static>)   // 영원히 살 수 있다

// ── C++: 개발자가 캡처 방식을 고르고, 틀리면 아무도 안 막는다 ──
//   auto f = [&]() { use(local); };   // 참조 캡처
//   return f;                          // 💥 local이 죽은 뒤 호출 → UB
//                                      //    컴파일 에러 아님!

// 스택 할당 — 명령어 하나
sub  sp, sp, #32        ; 스택 포인터를 32바이트 내린다. 끝.
; 해제도 명령어 하나 — 함수 반환 시 sp를 되돌린다
add  sp, sp, #32

// 힙 할당 — malloc 호출
;  1. 크기 클래스 결정
;  2. free list 탐색 (또는 스레드 로컬 캐시 확인)
;  3. 메타데이터 갱신
;  4. 멀티스레드면 동기화 (또는 per-thread arena)
;  → 수십~수백 사이클
;  해제도 마찬가지 + ARC라면 refCount 원자 연산까지

// 게다가 지역성 차이 (04번)
//   스택: 방금 쓴 프레임 근처 → 거의 항상 L1 캐시에 있다
//   힙  : 임의 위치 → 캐시 미스 가능 → 200+ 사이클

// ① 클로저 수명    → @escaping     → 스택 할당 가능      (10번, 이 페이지)
// ② 값 수명        → 값 타입       → ARC 자체가 불필요   (04번)
// ③ 소유권         → ~Copyable    → 복사 자체를 금지    (02번)
// ④ 격리 도메인    → Sendable      → 락 없이 안전        (07번)
// ⑤ 오버라이드 여부 → final         → 정적 디스패치       (05번)
//
// 전부 같은 문장이다:
//   "컴파일 타임에 알 수 있으면, 런타임에 확인할 필요가 없다."
//
// Swift의 어노테이션들이 귀찮게 느껴지는 이유도 여기 있다 —
// 그것들은 장식이 아니라 "컴파일러에게 주는 증명 재료"다.