any / some / Generic / Dispatch를 쉽게 이해하기

protocol Copyable {
    func copy() -> Self
}

final class Document: Copyable {
    var content: String
    required init(content: String) { self.content = content }

    func copy() -> Self {
        // self: 현재 인스턴스
        // Self: 반환해야 하는 현재 구체 타입
        type(of: self).init(content: content)
    }
}

protocol Drawable { func draw() }
struct Circle: Drawable { func draw() {} }
struct Square: Drawable { func draw() {} }

let mixed: [any Drawable] = [Circle(), Square()] // any: 혼합 저장

func makeDefaultShape() -> some Drawable {        // some: 단일 구현 숨김
    Circle()
}

protocol ImageLoading {
    func load(_ url: URL) async throws -> Data
}

struct URLImageLoader: ImageLoading {
    func load(_ url: URL) async throws -> Data { Data() }
}

struct CacheImageLoader: ImageLoading {
    func load(_ url: URL) async throws -> Data { Data() }
}

// 1) any: 서로 다른 타입을 한 컨테이너에 담기
let mixed: [any ImageLoading] = [URLImageLoader(), CacheImageLoader()]

// 2) some: 호출자에겐 숨기되, 실제 반환 타입은 하나
func makeStableLoader() -> some ImageLoading {
    URLImageLoader()
}

// 3) any 반환: 호출마다 다른 타입 반환 가능
func makeDynamicLoader(useCache: Bool) -> any ImageLoading {
    if useCache { return CacheImageLoader() }
    return URLImageLoader()
}

// 4) Generic 사용: 함수 레벨에서 구체 타입 최적화 여지
func render<L: ImageLoading>(loader: L) async throws {
    _ = try await loader.load(URL(string: "https://example.com")!)
}

// 5) any 파라미터도 가능
func renderAny(loader: any ImageLoading) async throws {
    _ = try await loader.load(URL(string: "https://example.com")!)
}

// A. 숨기지 않은 API (구체 타입 노출)
public struct URLAuthProvider {
    public func token() -> String { "t" }
}

public enum AuthFactory {
    public static func make() -> URLAuthProvider {
        URLAuthProvider()
    }
}

// B. 숨긴 API (계약만 노출)
public protocol AuthProviding {
    func token() -> String
}

struct URLAuthProvider: AuthProviding {
    func token() -> String { "t" }
}

public enum AuthFactory {
    public static func make() -> some AuthProviding {
        URLAuthProvider()
    }
}

// Swift 5.7+ Primary Associated Type
protocol Container<Item> {
    associatedtype Item
    var first: Item { get }
    func append(_ item: Item)
}

// 사용
let box: any Container<Int>   // Item이 Int인 Container (existential)
let box2: some Container<Int>  // Item이 Int인 Container (opaque)

func useGeneric<T: Container>(c: T) {
    // ✅ 아는 것 - Container 인터페이스 전부
    let item = c.first       // OK - T.Item 타입으로 반환
    c.append(item)           // OK - T.Item을 받는 메서드

    // ❌ 모르는 것 - Item의 구체 타입
    let n: Int = c.first     // 컴파일 에러 - Item이 Int인지 모름
}

// where 있음 - Item이 Int임을 알고 사용 가능
func useGeneric<T: Container>(c: T) where T.Item == Int {
    let item: Int = c.first  // OK, Int로 사용
}

// where 없음 - Item이 뭔지 모름
func useGeneric<T: Container>(c: T) {
    let item: T.Item = c.first  // OK, 추상적으로만 사용
    // let n: Int = c.first     // ❌ 컴파일 에러
}