06 · Optional 안전 사용

@frozen enum Optional<Wrapped> {
    case none
    case some(Wrapped)
}

// String? 는 Optional<String> 의 설탕이고, nil 은 .none 이다
let a: String? = nil
let b: Optional<String> = .none
let c: String? = .some("hi")
print(a == b)          // true — 같은 것

// 그래서 switch 로 다룰 수 있다
switch c {
case .none:          print("없음")
case .some(let v):   print(v)
}

// 옵셔널 체이닝이 String??? 이 되지 않는 이유 — 결과가 평탄화된다
struct A { var b: B? }
struct B { var c: String? }
let x: A? = A(b: B(c: "z"))
let y = x?.b?.c        // String?  ← String??? 이 아니다

let raw: String? = fetch()

// ① guard let — 기본값. 없으면 빠져나간다. happy path 들여쓰기 유지
guard let raw else { return }
print(raw.count)

// ② if let — 있을 때만 하는 "부수적" 처리
if let raw { badge.text = raw }

// ③ ?? — 의미 있는 기본값이 진짜로 존재할 때만
let title = raw ?? "제목 없음"

// ④ map — 있으면 변환, 없으면 nil 유지 (한 겹)
let len: Int? = raw.map { $0.count }

// ⑤ flatMap — 변환 결과가 또 Optional일 때 (평탄화)
let n: Int? = raw.flatMap { Int($0) }        // map이면 Int?? 가 된다

// ⑥ compactMap — 컬렉션에서 nil 제거
let nums = ["1", "x", "3"].compactMap { Int($0) }   // [1, 3]

// ⑦ 옵셔널 패턴 매칭 — enum과 섞일 때
for case let .some(v) in [raw] { print(v) }

// ⑧ switch — none/some 양쪽을 명시적으로 다뤄야 할 때
switch raw {
case .some(let v) where v.isEmpty: print("빈 문자열")
case .some(let v):                 print(v)
case .none:                        print("nil")
}

// ❌ 검사와 사용이 분리 — 컴파일러가 연결해 주지 못한다
if user != nil {
    print(user!.name)          // 여기서 user가 여전히 Optional
}
// ✅ 바인딩과 검사를 한 번에
guard let user else { return }
print(user.name)

// ❌ ?? 로 에러를 삼킨다 — "왜 0인지" 정보가 사라진다
let price = try? api.price() ?? 0

// ❌ 옵셔널 Bool — 3-state가 되어 조건문이 지옥이 된다
var isAgreed: Bool?
if isAgreed == true { }        // nil과 false를 구분해야 하나?
// ✅ 의미가 셋이면 enum
enum Consent { case unknown, agreed, declined }

// ❌ 중첩 옵셔널을 방치
let raw: String?? = someDict["k"]      // 사전에 키가 없음 vs 값이 nil
// ✅ 의미를 결정해서 평탄화
let flat: String? = someDict["k"] ?? nil

// ❌ 옵셔널 배열 vs 배열의 옵셔널을 혼동
var items1: [Item]?  = nil     // "목록 자체가 아직 없음"
var items2: [Item?]  = []      // "목록은 있는데 원소가 비어 있을 수 있음"
var items3: [Item]   = []      // "목록은 있고 비어 있음"  ← 대부분 이게 맞다

// ─── ① 정상적으로 값이 없을 수 있다 → Optional 이 맞다 ───
struct User {
    let id: UUID
    let nickname: String?      // 닉네임을 안 쓰는 건 정상이다
}

// ─── ② 실패다. 그리고 이유가 있다 → throws 가 맞다 ───
// ❌ nil은 "왜 실패했는지"를 버린다
func loadUser(id: UUID) -> User? { /* ... */ }
// ✅ 이유가 전달된다
func loadUser(id: UUID) throws -> User { /* ... */ }
enum LoadError: Error { case notFound, network, unauthorized }

// ─── ③ 상태가 여러 개다 → Optional 로 뭉개면 정보가 없어진다 ───
// ❌ users == nil 이 "로딩 중"인지 "실패"인지 "아직 시작 안 함"인지 모른다
var users: [User]?
// ✅ 상태를 열거한다  (01번의 상태 공간 축소와 같은 이야기)
enum LoadState {
    case idle
    case loading
    case loaded([User])
    case failed(LoadError)
}

// 서버 DTO — 서버가 언제든 필드를 빼먹을 수 있으니 전부 옵셔널
struct UserDTO: Decodable {
    let id: String?
    let name: String?
    let age: Int?
    let profileURL: String?
}

// ❌ DTO를 그대로 화면까지 흘려보내면 if let 이 UI 코드까지 번진다
label.text = dto.name ?? ""
if let urlString = dto.profileURL, let url = URL(string: urlString) { /* ... */ }

// ✅ 디코딩 계층에서 세 가지를 "결정"해서 내려보낸다
struct User {                       // 도메인 모델 — 옵셔널이 최소
    let id: UUID                    // 없으면 에러 (필수)
    let name: String                // 없으면 기본값
    let age: Int?                   // 진짜 선택 항목 — 옵셔널 유지
    let profileURL: URL?            // 파싱 실패도 nil로 흡수
}

extension User {
    init(dto: UserDTO) throws {
        guard let idString = dto.id, let id = UUID(uuidString: idString) else {
            throw LoadError.invalidPayload("id")     // ① 실패로 승격
        }
        self.id = id
        self.name = dto.name ?? "이름 없음"           // ② 기본값 적용
        self.age = dto.age                            // ③ 옵셔널 유지
        self.profileURL = dto.profileURL.flatMap(URL.init(string:))
    }
}
// 결과: 화면 코드에 if let 이 거의 사라진다

// ❌ 왜 죽었는지 크래시 로그에 안 남는다
let url = URL(string: endpoint)!

// ✅ 실패 이유가 로그에 찍힌다
guard let url = URL(string: endpoint) else {
    preconditionFailure("잘못된 endpoint: \(endpoint)")
}

// ✅ 정당한 ! 의 예 — 뷰 로드 후엔 반드시 존재
@IBOutlet private var titleLabel: UILabel!

// ✅ 방금 넣은 값을 바로 꺼낼 때 (그래도 주석으로 근거를 남긴다)
cache[key] = value
let stored = cache[key]!    // 바로 위에서 넣었으므로 nil 불가

MemoryLayout<Int>.size          // 8
MemoryLayout<Int?>.size         // 9   ← 1바이트 늘었다
MemoryLayout<Int?>.stride       // 16  ← 정렬 때문에 배열 간격은 16

MemoryLayout<String>.size       // 16
MemoryLayout<String?>.size      // 16  ← 늘지 않았다!

class C {}
MemoryLayout<C>.size            // 8
MemoryLayout<C?>.size           // 8   ← 늘지 않았다!

MemoryLayout<Bool>.size         // 1
MemoryLayout<Bool?>.size        // 1   ← 늘지 않았다!
MemoryLayout<Bool??>.size       // 1   ← 두 겹인데도 안 늘었다

MemoryLayout<Bool>.size      // 1  — Bool은 0과 1만 쓴다 → 2~255가 전부 여분
MemoryLayout<Bool?>.size     // 1  — nil을 2로 표현
MemoryLayout<Bool??>.size    // 1  — 바깥 nil을 3으로 표현
MemoryLayout<Bool???>.size   // 1  — 4로... 여분이 남는 한 계속 공짜

// 반대로 Int는 여분이 없으니 한 겹부터 태그가 필요하다
MemoryLayout<Int?>.size      // 9
MemoryLayout<Int??>.size     // 10  ← 겹마다 1바이트씩 늘어난다

var s: String! = "hi"
let t = s            // t의 타입은 String? 이다 (String이 아니다!)
print(type(of: t))   // Optional<String>

s = nil
print(s.count)       // 💥 크래시 — 사용 시점에 자동 강제 언래핑

// 남아 있는 이유
//   ① ObjC API 브리징 — nullability 표기가 없는 헤더는 IUO로 들어온다
//   ② 2단계 초기화 — @IBOutlet 은 init 때 nil, 뷰 로드 후 채워진다

// 새 코드에서 쓰는 것 = "여기서 nil이면 크래시"를 암묵적으로 선언하는 것
// → 명시적으로 쓰는 게 낫다
private var config: Config!                     // ❌ 암묵적
private var config: Config?                     // ✅ 명시적으로 다룬다
private lazy var config: Config = makeConfig()  // ✅ 더 나은 대안

|Bool|          = 2                    // true, false
|Optional<T>|   = |T| + 1              // T의 모든 값 + nil 하나

|Bool?|         = 2 + 1 = 3            // true, false, nil
|Bool??|        = 3 + 1 = 4
|(Bool, Bool)|  = 2 × 2 = 4            // 곱 타입 (struct/tuple)
|Bool?  × Bool| = 3 × 2 = 6

// 그래서 이런 판단이 "취향"이 아니라 "계산"이 된다
struct Bad  { var loading: Bool; var error: Error?; var data: [Item]? }
//            2 × (많음+1) × (많음+1)  ← 대부분이 무효 상태

enum Good { case idle, loading, loaded([Item]), failed(Error) }
//          정확히 4가지 — 무효 상태가 존재하지 않는다

// Java / Objective-C / C
String s = null;      // String 타입인데 String이 아닌 값이 들어간다
NSString *s = nil;    // 타입은 NSString*, 값은 없음 — 타입이 거짓말을 한다

// 이게 왜 치명적인가:
//   ① 타입 시그니처가 "이 값이 없을 수 있음"을 말해 주지 않는다
//   ② 컴파일러가 검사를 강제할 근거가 없다
//   ③ 오류가 "생성 지점"이 아니라 "사용 지점"에서 터진다 (원인에서 멀다)

// Swift의 해법 — 없을 수 있음을 "다른 타입"으로 만든다
let a: String  = ...   // 절대 nil이 아님이 타입으로 보장된다
let b: String? = ...   // 없을 수 있음이 타입에 적혀 있다
// String 과 String? 은 서로 다른 타입이라 대입조차 안 된다

// map:     (T) -> U           를 받아  T? -> U?
// flatMap: (T) -> U?          를 받아  T? -> U?      ← 결과를 평탄화

let s: String? = "42"
let a = s.map { Int($0) }        // Int??  ← 두 겹이 됐다
let b = s.flatMap { Int($0) }    // Int?   ← 평탄화됨

// 이 "평탄화하며 잇기"가 모나드의 bind 연산이다.
// 옵셔널 체이닝이 바로 이것의 문법 설탕이다 —
//   user?.address?.city 는 개념적으로 flatMap 연쇄와 같은 구조이고,
//   그래서 결과가 City??? 가 아니라 City? 로 평탄화된다.

// 그래서 이런 파이프라인이 자연스럽게 나온다 — 어디서든 nil이면 전체가 nil
let url: URL? = configString
    .flatMap { Int($0) }              // String? -> Int?
    .map    { "https://api/\($0)" }   // Int?    -> String?
    .flatMap(URL.init(string:))       // String? -> URL?

// ⚠️ 함정: Optional의 flatMap 과 Sequence의 flatMap 은 다른 것이다
//    Sequence의 "nil 제거" 용도는 compactMap 으로 이름이 분리됐다

// 8바이트 정렬된 객체의 주소는 항상 8의 배수다
0x1000  = ...0001 0000 0000 0000    하위 3비트 = 000
0x1008  = ...0001 0000 0000 1000    하위 3비트 = 000
0x1010  = ...0001 0000 0001 0000    하위 3비트 = 000
                                    ↑ 이 3비트는 언제나 0 = 낭비

// → 여기에 태그 3비트를 넣고, 역참조 전에 마스킹해서 지운다
let tagged = address | 0b011        // 태그 심기
let real   = tagged & ~0b111        // 태그 지우고 실제 주소 얻기

// Swift의 extra inhabitant도 정확히 같은 발상이다:
//   "쓰이지 않는 표현 공간이 있으면, 공짜로 정보를 더 담을 수 있다"