06 · 클로저와 캡처

func makeCounter() -> () -> Int {
    var count = 0
    return {
        count += 1
        return count
    }
}

let counterA = makeCounter()
let counterB = counterA   // 참조 복사 — 같은 캡처 컨텍스트를 공유

print(counterA())  // 1
print(counterB())  // 2  (counterA가 아니라 counterB로 불렀는데도 카운트가 이어진다)
print(counterA())  // 3

final class BadgeCounter {
    private var handlers: [() -> Void] = []
    private(set) var count = 0

    func addHandler(_ handler: @escaping () -> Void) {
        handlers.append(handler)
    }

    func bump() {
        count += 1
        handlers.forEach { $0() }   // 등록된 모든 클로저가 "같은" self.count를 본다
    }
}
// handlers에 쌓인 클로저들은 서로 다른 인스턴스지만, 전부 같은 self를 참조 캡처하고 있어
// count 하나를 공유해서 본다 — "여러 개를 등록했으니 독립적이겠지"라는 가정이 틀리는 지점.

func makeSnapshotHandler(current: Int) -> () -> Void {
    // [current]로 캡처하면 이 함수가 호출된 시점의 값이 클로저 안에 고정된다.
    // 캡처 리스트 없이 그냥 클로저를 쓰면 나중에 바뀐 current(있다면)를 보게 될 수 있다.
    { [current] in print("등록 당시 값:", current) }
}

// --- non-escaping: withNonEscaping(_ body: () -> Void) 안에서 만든 클로저 ---
%0 = alloc_stack [var_decl] $Int, var, name "counter"      // counter 자체가 스택에
%4 = function_ref @...closure#1...
%5 = partial_apply [callee_guaranteed] [on_stack] %4(%0)   // 컨텍스트도 스택 — [on_stack]
%7 = apply %6(%5) : $@convention(thin) (@guaranteed @noescape @callee_guaranteed () -> ()) -> ()
dealloc_stack %5                                            // 컨텍스트 명시적 해제
dealloc_stack %0                                            // counter 명시적 해제

// --- escaping: withEscaping(_ body: @escaping () -> Void) 안에서 만든 클로저 ---
%0 = alloc_box ${ var Int }, var, name "counter"            // counter 자체가 힙 박스로
%1 = project_box %0, 0
%5 = function_ref @...closure#1...
strong_retain %0                                             // 컨텍스트를 넘기기 전에 retain
%7 = partial_apply [callee_guaranteed] %5(%0)                // [on_stack] 없음 — 힙 컨텍스트
%9 = apply %8(%7) : $@convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> ()
strong_release %7
strong_release %0                                             // counter box release

// ✅ map처럼 함수 실행 중에만 호출되는 변환 클로저 — non-escaping이 기본값이라 표시 불필요
func transform(_ values: [Int], _ f: (Int) -> Int) -> [Int] {
    values.map(f)
}

// ✅ 네트워크 콜백처럼 함수가 반환된 뒤(비동기로) 호출되는 경우만 @escaping
func fetchUser(id: String, completion: @escaping (User?) -> Void) {
    URLSession.shared.dataTask(with: makeURL(for: id)) { data, _, _ in
        completion(User(data: data))   // 함수 fetchUser는 이미 반환된 뒤에 호출된다
    }.resume()
}

func apply(_ closures: [() -> Void]) {
    // 표준 라이브러리 API가 @escaping을 요구하지만, 이 함수 안에서만 쓰고 끝난다는 걸 보장할 때
    withoutActuallyEscaping(closures[0]) { escapable in
        [escapable].forEach { $0() }
    }
}

var x = 0
let byReference = { print("참조 캡처:", x) }
let byValue = { [x] in print("캡처 리스트:", x) }

x = 100

byReference()  // 참조 캡처: 100 — 지금(호출 시점) x 값을 읽는다
byValue()      // 캡처 리스트: 0   — 클로저 생성 시점의 값이 이미 고정되어 있다

var scheduled: [() -> Void] = []

for i in 0..<3 {
    // [i]가 없으면 i는 참조 캡처되어, 나중에 배열을 실행할 때 세 클로저 모두
    // "그 시점의 i" — 즉 이미 반복이 끝난 뒤의 값을 보게 될 수 있다.
    scheduled.append { [i] in print("작업", i, "실행") }
}

scheduled.forEach { $0() }   // 작업 0 실행 / 작업 1 실행 / 작업 2 실행 — 생성 시점 값 그대로

final class Uploader {
    let uploadID = UUID()

    func start(_ completion: @escaping (Bool) -> Void) {
        // self는 weak로, uploadID는 지금 이 순간 값으로 스냅샷 떠서 로그에 남긴다.
        // self.uploadID를 나중에 self를 통해 다시 읽는 것과 달리, 이 값은 self 생사와 무관하게 남는다.
        performUpload { [weak self, id = self.uploadID] success in
            print("업로드", id, success ? "성공" : "실패")
            self?.finish(success)
        }
    }
    func finish(_ success: Bool) {}
    func performUpload(_ completion: @escaping (Bool) -> Void) { completion(true) }
}

import Foundation

// (a) 클로저를 프로퍼티에 저장 + self 강한 캡처
final class Leaky {
    var onDone: (() -> Void)?
    var name = "Leaky"
    func setup() { onDone = { print("done:", self.name) } }
    deinit { print("  ✅ Leaky.deinit") }
}

// (b) 완전히 같은 코드에 [weak self] 만 추가
final class Fixed {
    var onDone: (() -> Void)?
    var name = "Fixed"
    func setup() { onDone = { [weak self] in print("done:", self?.name ?? "-") } }
    deinit { print("  ✅ Fixed.deinit") }
}

// (c) 저장하지 않는 일회성 비동기 — self 를 강하게 캡처해도 된다
final class OneShot {
    var name = "OneShot"
    func run(_ done: @escaping () -> Void) {
        DispatchQueue.global().async { print("done:", self.name); done() }
    }
    deinit { print("  ✅ OneShot.deinit") }
}

do { var a: Leaky? = Leaky(); a?.setup(); a = nil }
do { var b: Fixed? = Fixed(); b?.setup(); b = nil }
let sem = DispatchSemaphore(value: 0)
do { var c: OneShot? = OneShot(); c?.run { sem.signal() }; sem.wait(); c = nil }

(a) 프로퍼티에 저장 + 강한 self:
   ↑ deinit 이 안 찍혔으면 누수          ← Leaky.deinit 이 출력되지 않았다

(b) 같은 코드 + [weak self]:
  ✅ Fixed.deinit

(c) 저장하지 않는 일회성:
done: OneShot
  ✅ OneShot.deinit

final class ProfileViewController: UIViewController {
    func loadAvatar() {
        // 이 completion은 어디에도 저장되지 않고, 네트워크 콜백 한 번으로 끝난다.
        // self → 클로저까지만 있고, 클로저를 들고 있는 URLSession task가
        // 완료 후 release하므로 self로 되돌아오는 화살표가 없다 — 순환 아님.
        APIClient.fetchAvatar { [self] image in
            avatarView.image = image
        }
    }
}

import Combine

final class FeedViewModel {
    private var cancellables: Set<AnyCancellable> = []
    private let refreshed = PassthroughSubject<Void, Never>()

    func bind() {
        refreshed
            .sink { [weak self] in
                // self → cancellables → 이 AnyCancellable → 클로저 컨텍스트 → self로
                // 되돌아오는 순환을, weak self가 마지막 화살표에서 끊어준다.
                self?.reload()
            }
            .store(in: &cancellables)   // self가 이 구독을 소유
    }
    func reload() {}
}

final class Fetcher {
    var value = 0

    func load(_ completion: @escaping () -> Void) {
        DispatchQueue.global().async { [weak self] in
            guard let self else { return }
            // Swift 5.7까지: 언랩한 뒤에도 매번 self.을 명시해야 컴파일됐다
            self.value += 1
            // Swift 5.8부터(SE-0365): guard let self로 언랩한 뒤에는
            // 암묵적 self로도 같은 self를 가리키는 게 보장된다
            value += 1
            completion()
        }
    }
}

final class Resource { let id = 7; deinit { print("  Resource.deinit") } }
var strongRef: Resource? = Resource()
weak var weakRef = strongRef
unowned let unownedRef = strongRef!
print("해제 전 weakRef   :", weakRef as Any)
print("해제 전 unownedRef:", unownedRef.id)
strongRef = nil
print("해제 후 weakRef   :", weakRef as Any)

해제 전 weakRef   : Optional(q5a.Resource)
해제 전 unownedRef: 7
  Resource.deinit
해제 후 weakRef   : nil        ← 대입한 적이 없는데 nil 이 되어 있다
exit code = 0

final class Resource { let id = 7; deinit { print("  Resource.deinit") } }
var strongRef: Resource? = Resource()
unowned let unownedRef = strongRef!
strongRef = nil
print("해제 후 unownedRef.id 접근 시도…")
print(unownedRef.id)          // ← 여기서 트랩

Fatal error: Attempted to read an unowned reference but object 0x100e4e0e0
             was already destroyed
  Resource.deinit
해제 후 unownedRef.id 접근 시도…
exit code = 134        # 128 + 6 (SIGABRT)

final class SearchViewModel {
    let api = API()

    func search(_ query: String, completion: @escaping ([Result]) -> Void) {
        api.search(query) { [weak self] results in
            guard let self else { return }
            self.cache(results)
            completion(results)
        }
    }
    func cache(_ results: [Result]) {}
}
struct Result {}
final class API {
    func search(_ q: String, completion: @escaping ([Result]) -> Void) { completion([]) }
}

final class HTMLElement {
    let name: String
    let text: String?

    // asHTML은 self의 저장 프로퍼티이고, self가 살아있는 동안에만 호출될 클로저다.
    // self가 사라지면 이 클로저도 함께 사라지므로, weak의 옵셔널 언래핑이 오히려 불필요하다.
    lazy var asHTML: () -> String = { [unowned self] in
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }

    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }
}

func logIfNeeded(_ enabled: Bool, _ message: @autoclosure () -> String) {
    if enabled {
        print("[LOG]", message())   // 여기서 처음 평가된다
    }
    // enabled가 false면 message()는 한 번도 호출되지 않는다
}

func expensiveDescription() -> String {
    print("비용이 큰 문자열을 실제로 만드는 중...")
    return "무거운 디버그 설명"
}

logIfNeeded(false, expensiveDescription())
// 이 한 줄만으로는 "비용이 큰 문자열을 실제로 만드는 중..."이 출력되지 않는다 —
// enabled가 false라서 message()가 아예 호출되지 않았기 때문이다.

func require(_ condition: Bool, _ reason: @autoclosure () -> String) {
    if !condition {
        fatalError(reason())   // 실패했을 때만 reason()이 평가된다
    }
}

require(1 + 1 == 2, "산수가 깨졌다: \(1 + 1)")   // 통과 — 문자열 보간조차 실행 안 됨

struct LazyDefault<Value> {
    private let makeValue: () -> Value

    // 호출부는 그냥 값을 넘기는 것처럼 보이지만, 평가는 resolve()가 불릴 때까지 미뤄진다.
    init(_ makeValue: @autoclosure @escaping () -> Value) {
        self.makeValue = makeValue
    }
    func resolve() -> Value { makeValue() }
}

func computeExpensiveDefault() -> Int {
    print("기본값을 실제로 계산하는 중...")
    return 42
}

let fallback = LazyDefault(computeExpensiveDefault())   // 아직 계산 안 됨
// ... 나중에, 정말 필요해지면
let value = fallback.resolve()                           // 여기서 처음 계산된다