05 · 프로퍼티

struct Box {
    private var storage: [Int] = []
    var items: [Int] {
        get { print("get 호출"); return storage }
        set { print("set 호출"); storage = newValue }
        _modify {
            print("_modify 진입")
            yield &storage
            print("_modify 탈출")
        }
    }
}

var b = Box()
b.items.append(1)   // "_modify 진입" → "_modify 탈출"만 찍힌다. get/set 왕복이 없다.
b.items = [9]        // "set 호출"만 찍힌다 — 전체 재대입은 set 경로를 그대로 탄다.
print(b.items)        // "get 호출"

final class Cache<Value> {
    private var storage: Value

    init(_ initial: Value) { storage = initial }

    // ❌ 공개 API로 '_modify'를 그대로 노출하면 컴파일러 업데이트에 취약하다.
    // ✅ 대신 mutating 클로저를 받는 메서드로 '그 자리에서 고치는' API를 흉내낸다.
    func modify(_ body: (inout Value) -> Void) {
        body(&storage)   // 여기서 딱 한 번만 '직접 참조'를 넘긴다
    }
}

let cache = Cache([1, 2, 3])
cache.modify { $0.append(4) }   // 복사-왕복 없이 storage를 바로 고침

struct RingBuffer<Element> {
    private var storage: [Element]

    // ⚠️ _modify는 언더스코어 실험적 기능. 모듈 내부 구현에만 쓰고
    //    라이브러리 공개 인터페이스(공개 subscript)에는 노출하지 않는다.
    subscript(index: Int) -> Element {
        get { storage[index] }
        set { storage[index] = newValue }
        _modify { yield &storage[index] }
    }
}

class A {
    var value: Int = 0 {
        willSet { print("willSet: \(value) -> \(newValue)") }
        didSet  { print("didSet: \(oldValue) -> \(value)") }
    }
    init(v: Int) {
        self.value = v   // 여기서는 아무것도 출력되지 않는다 (자기 자신의 init 안)
    }
}
let a = A(v: 10)   // 출력 없음
a.value = 20       // "willSet: 10 -> 20" / "didSet: 10 -> 20"

func noop(_ x: inout Int) {
    // 아무 것도 안 바꾼다
}
noop(&a.value)     // 그런데도 "willSet: 20 -> 20" / "didSet: 20 -> 20"이 찍힌다

struct Settings {
    var theme: String = "dark" {
        didSet {
            // ❌ 이렇게만 쓰면 inout으로 &settings.theme를 넘기기만 해도
            //    값이 그대로인데 저장이 매번 실행된다.
            // persist(theme)

            // ✅ 실제로 바뀐 경우에만 저장한다
            guard theme != oldValue else { return }
            persist(theme)
        }
    }
}

func persist(_ value: String) {
    print("디스크에 저장: \(value)")
}

class ProfileViewModel {
    var displayName: String {
        didSet { notifyNameChanged() }
    }

    init(displayName: String) {
        self.displayName = displayName   // didSet 안 불림 — 자기 init 안이므로
        notifyNameChanged()               // ✅ 필요한 로직이면 직접 한 번 불러준다
    }

    private func notifyNameChanged() {
        print("이름 변경 알림: \(displayName)")
    }
}

// 당신이 쓰는 코드
final class Configuration {
    lazy var expensiveValue: Int = computeExpensiveValue()
}

// 컴파일러가 만드는 코드의 '대략적인' 모양
final class Configuration {
    private var _lazyStorage_expensiveValue: Int? = nil

    var expensiveValue: Int {
        get {
            if let value = _lazyStorage_expensiveValue {
                return value           // 이미 있으면 그대로 반환
            }
            let value = computeExpensiveValue()  // 없으면 여기서 계산
            _lazyStorage_expensiveValue = value   // 계산한 값을 저장
            return value
        }
        set { _lazyStorage_expensiveValue = newValue }
    }
}

final class Configuration {
    lazy var expensiveValue: Int = {
        print("계산 시작: \(Thread.current)")
        Thread.sleep(forTimeInterval: 0.01)
        return 42
    }()
}

let config = Configuration()
DispatchQueue.concurrentPerform(iterations: 8) { _ in
    _ = config.expensiveValue
}
// "계산 시작: ..."이 1번이 아니라 여러 번 찍힐 수 있다 (비결정적 재현)

final class LazyBox<Value> {
    private let lock = NSLock()
    private var storage: Value?
    private let make: () -> Value

    init(_ make: @escaping () -> Value) { self.make = make }

    var value: Value {
        lock.lock(); defer { lock.unlock() }
        if let v = storage { return v }
        let v = make()
        storage = v
        return v
    }
}

final class Configuration {
    // 실제로 비싼 계산이 여기 들어간다
    static func computeExpensiveValue() -> Int { (1...1_000_000).reduce(0, +) }

    private let _expensive = LazyBox { Configuration.computeExpensiveValue() }
    var expensiveValue: Int { _expensive.value }   // 이제 동시 접근에도 안전
}

final class FeedViewController: UIViewController {
    // ✅ viewDidLoad, cellForItemAt 등 모두 메인 스레드에서만 호출되므로
    //    락 없는 lazy var로도 충분하다. 과잉 방어가 오히려 코드만 무겁게 한다.
    lazy var layout: UICollectionViewFlowLayout = {
        let l = UICollectionViewFlowLayout()
        l.minimumLineSpacing = 8
        return l
    }()
}

// 당신이 쓰는 코드
@Wrapper var foo = 1738

// 컴파일러가 생성하는 코드
private var _foo: Wrapper<Int> = Wrapper<Int>(wrappedValue: 1738)
var foo: Int {
    get { return _foo.wrappedValue }
    set { _foo.wrappedValue = newValue }
}
// wrapper가 projectedValue를 정의했다면 추가로:
var $foo: Wrapper<Int>.Projection {
    get { _foo.projectedValue }
}

@propertyWrapper
struct Clamped<Value: Comparable> {
    private let range: ClosedRange<Value>
    var wrappedValue: Value {
        didSet { wrappedValue = min(max(wrappedValue, range.lowerBound), range.upperBound) }
    }
    init(wrappedValue: Value, _ range: ClosedRange<Value>) {
        self.range = range
        self.wrappedValue = min(max(wrappedValue, range.lowerBound), range.upperBound)
    }
}

func setHealth(@Clamped(0...100) _ value: Int) {
    print(value)   // 호출부가 무슨 값을 넘기든 이미 0...100으로 잘려 들어온다
}

setHealth(150)   // 함수 안에서 value는 100

// 터미널에서
// swiftc -emit-silgen MyFile.swift | grep -E "_foo|\\$foo|foo"
// 로 _foo(백킹 저장소), foo(get/set), $foo(프로젝션) 세 심볼이
// 각각 별도 접근자로 컴파일되는 걸 확인할 수 있다.

@propertyWrapper
struct Loud<Value> {
    private var value: Value
    var wrappedValue: Value {
        get { value }
        set { value = newValue; print("바뀜: \(value)") }
    }
    var projectedValue: String { "Loud(\(value))" }
    init(wrappedValue: Value) { value = wrappedValue }
}

struct Demo {
    @Loud var count = 0
}
var d = Demo()
d.count += 1      // "바뀜: 1"
print(d.$count)   // "Loud(1)" — $count는 projectedValue를 그대로 반환

@propertyWrapper
struct Clamped<Value: Comparable> {
    let range: ClosedRange<Value>
    var wrappedValue: Value {
        didSet { wrappedValue = min(max(wrappedValue, range.lowerBound), range.upperBound) }
    }
    init(wrappedValue: Value, _ range: ClosedRange<Value>) {
        self.range = range
        self.wrappedValue = min(max(wrappedValue, range.lowerBound), range.upperBound)
    }
}

struct Player {
    @Clamped(0...100) var health = 100

    // _health 는 컴파일러가 만들어주는 저장 프로퍼티이고 항상 private 이다.
    // 그래서 래퍼 자체의 API(range 등)는 '타입 안에서만' 꺼낼 수 있다.
    var healthRange: ClosedRange<Int> { _health.range }
}

var p = Player()
p.health -= 200
print(p.health)        // 0   — didSet 이 범위로 잘라냈다
print(p.healthRange)   // 0...100

// print(p._health.range)
// ❌ error: &#x27;_health&#x27; is inaccessible due to &#x27;private&#x27; protection level
//    바깥에서 래퍼 본체에 닿고 싶으면 projectedValue($health)를 열어줘야 한다.

@propertyWrapper struct Trimmed {
    private var v = ""
    var wrappedValue: String {
        get { v }
        set { v = newValue.trimmingCharacters(in: .whitespaces) }
    }
    init(wrappedValue: String) { self.wrappedValue = wrappedValue }
}

// ❌ 같은 타입(String)을 다루는 비제네릭 래퍼 둘은 애초에 합성되지 않는다
// @propertyWrapper struct Capitalized { var wrappedValue: String ... }
// struct A { @Trimmed @Capitalized var name: String }
// error: composed wrapper type 'Capitalized' does not match type of
//        'Trimmed.wrappedValue', which is 'String'

// ✅ 바깥 래퍼가 '제네릭'이어야 안쪽 래퍼를 값으로 감쌀 수 있다
@propertyWrapper struct Logged<Value> {
    private var v: Value
    var wrappedValue: Value {
        get { v }
        set { print("Logged가 받은 값:", newValue); v = newValue }
    }
    init(wrappedValue: Value) { v = wrappedValue }
}

struct Form {
    @Logged @Trimmed var name: String = "  hyosung  "
}

var f = Form()
print("[\(f.name)]")     // [hyosung]  — 읽을 때는 안쪽까지 자동으로 이어진다
f.name = "  park "
// 출력: Logged가 받은 값: Trimmed(v: "park")
print("[\(f.name)]")     // [park]

// 핵심: 바깥 래퍼가 보는 값은 String이 아니라 '안쪽 래퍼 그 자체'다.
// @Logged @Trimmed 는 Logged&lt;Trimmed&gt; 이고, 순서를 바꾸면 감싸는 방향이
// 통째로 뒤집히므로 합성 순서는 결과와 타입 양쪽을 바꾼다.

struct Point { var x: Int; var y: Int }
final class Counter { var count: Int = 0 }

let wp: WritableKeyPath<Point, Int> = \Point.x
var p = Point(x: 1, y: 2)          // var여야 쓰기 가능
p[keyPath: wp] = 10                 // OK

let rwp: ReferenceWritableKeyPath<Counter, Int> = \Counter.count
let c = Counter()                   // c 자체는 let!
c[keyPath: rwp] = 5                 // OK — c라는 참조는 안 바뀌고 count만 바뀐다

struct Point {
    var x: Int
    let y: Int   // let!
}

let kx: KeyPath<Point, Int> = \.x          // OK — 읽기 전용이면 항상 성립
let wx: WritableKeyPath<Point, Int> = \.x  // OK — x는 var라서 쓰기 가능

// let wy: WritableKeyPath<Point, Int> = \.y
// ❌ 컴파일 에러: y는 let이라 WritableKeyPath 자체를 만들 수 없다

struct User { let name: String; var age: Int }

func sorted<T, V: Comparable>(_ items: [T], by keyPath: KeyPath<T, V>) -> [T] {
    items.sorted { $0[keyPath: keyPath] < $1[keyPath: keyPath] }
}

let users = [User(name: "B", age: 30), User(name: "A", age: 20)]
let byAge = sorted(users, by: \.age)     // 제네릭 정렬 — 필드마다 새 함수 필요 없음
let names = users.map(\.name)             // SE-0249 — key path 리터럴을 함수처럼 바로 전달

final class ProfileViewModel {
    var displayName: String = ""
    var age: Int = 0
}

func bind<Root: AnyObject, Value>(
    _ root: Root,
    _ keyPath: ReferenceWritableKeyPath<Root, Value>,
    to value: Value
) {
    root[keyPath: keyPath] = value   // root가 let이어도 내부는 바뀐다
}

let vm = ProfileViewModel()          // let — 하지만 참조 타입이라 문제 없음
bind(vm, \.displayName, to: "효성")
bind(vm, \.age, to: 30)