类型擦除

protocol Animal {
    func makeSound() -> String
}

struct Dog: Animal {
    func makeSound() -> String { "Woof!" }
}

struct Cat: Animal {
    func makeSound() -> String { "Meow!" }
}

// animals 数组中的每个元素都是存在类型
// 编译器不知道每个元素的具体类型，只知道"存在某个类型遵循了 Animal"
var animals: [any Animal] = [Dog(), Cat()]

// 编译器知道返回的就是 Dog，但调用者只知道是 "some Animal"
func makePet() -> some Animal {
    return Dog()
}

protocol Container {
    associatedtype Item
    func add(_ item: Item)
    func get(at index: Int) -> Item
}

// 错误：Protocol 'Container' can only be used as a generic constraint 
// because it has Self or associated type requirements
let containers: [Container] = []  // 编译错误

// 错误：无法直接返回带有关联类型的协议
func makeContainer() -> Container { }  // 编译错误

protocol Animal {
    associatedtype Food
    func eat(_ food: Food)
    func makeSound() -> String
}

struct Dog: Animal {
    func eat(_ food: String) {
        print("Dog eating \(food)")
    }
    func makeSound() -> String { return "Woof!" }
}

struct Cat: Animal {
    func eat(_ food: Int) {
        print("Cat eating \(food)")
    }
    func makeSound() -> String { return "Meow!" }
}

// 使用any进行类型擦除
let animals: [any Animal] = [Dog(), Cat()]

for animal in animals {
    print(animal.makeSound())
}

// 函数参数和返回值
func processAnimal(_ animal: any Animal) {
    print(animal.makeSound())
}

func getRandomAnimal() -> any Animal {
    return Bool.random() ? Dog() : Cat()
}

// 定义协议
protocol Animal {
    associatedtype Food
    func eat(_ food: Food)
    func makeSound() -> String
}

// 具体实现
struct Dog: Animal {
    typealias Food = String
    func eat(_ food: String) { print("Dog eating \(food)") }
    func makeSound() -> String { return "Woof!" }
}

struct Cat: Animal {
    typealias Food = String
    func eat(_ food: String) { print("Cat eating \(food)") }
    func makeSound() -> String { return "Meow!" }
}

// 类型擦除包装器
class AnyAnimal<Food>: Animal {
    private let _eat: (Food) -> Void
    private let _makeSound: () -> String
    
    init<A: Animal>(_ animal: A) where A.Food == Food {
        _eat = animal.eat
        _makeSound = animal.makeSound
    }
    
    func eat(_ food: Food) {
        _eat(food)
    }
    
    func makeSound() -> String {
        return _makeSound()
    }
}

// 使用类型擦除
let animals: [AnyAnimal<String>] = [
    AnyAnimal(Dog()),
    AnyAnimal(Cat())
]

for animal in animals {
    print(animal.makeSound())
    animal.eat("food")
}

protocol Drawable {
    associatedtype Output
    func draw() -> Output
}

// 1. 抽象基类
private class _AnyDrawableBase<Output>: Drawable {
    func draw() -> Output {
        fatalError("Must be overridden")
    }
}

// 2. 具体Box类
private class _AnyDrawableBox<T: Drawable>: _AnyDrawableBase<T.Output> {
    private let _base: T
    
    init(_ base: T) {
        self._base = base
    }
    
    override func draw() -> Output {
        return _base.draw()
    }
}

// 3. 公开的类型擦除包装器
struct AnyDrawable<Output>: Drawable {
    private let _box: _AnyDrawableBase<Output>
    
    init<T: Drawable>(_ drawable: T) where T.Output == Output {
        _box = _AnyDrawableBox(drawable)
    }
    
    func draw() -> Output {
        return _box.draw()
    }
}

let array = [1, 2, 3, 4, 5]
let set: Set = [6, 7, 8, 9, 10]

// 将不同类型的序列统一为AnySequence
let sequences: [AnySequence<Int>] = [
    AnySequence(array),
    AnySequence(set)
]

for sequence in sequences {
    for element in sequence {
        print(element)
    }
}

let array = [1, 2, 3]
let anyCollection = AnyCollection(array)

print(anyCollection.count)  // 3
print(anyCollection.first)  // Optional(1)

var count = 0
let iterator = AnyIterator<Int> {
    count += 1
    return count <= 5 ? count : nil
}

for value in IteratorSequence(iterator) {
    print(value)  // 1, 2, 3, 4, 5
}

let intValue: Int = 42
let stringValue: String = "Hello"

// AnyHashable可以包装任何Hashable类型
let hashables: [AnyHashable] = [
    AnyHashable(intValue),
    AnyHashable(stringValue)
]

// 可以用作字典的键
var dict: [AnyHashable: String] = [:]
dict[AnyHashable(42)] = "forty-two"
dict[AnyHashable("key")] = "value"

// 简化后的标准库实现
public struct AnySequence<Element>: Sequence {
    internal let _box: _AnySequenceBox<Element>
    
    public init<S: Sequence>(_ base: S) where S.Element == Element {
        self._box = _SequenceBox(base)  // 具体类型 S 在此处被向上转型擦除
    }
}

// 抽象基类：只保留泛型参数 Element，不包含具体序列类型
internal class _AnySequenceBox<Element> {
    func makeIterator() -> AnyIterator<Element> { fatalError() }
}

// 具体 Box 子类：持有原始序列，具体类型 S 藏在子类中
internal final class _SequenceBox<S: Sequence>: _AnySequenceBox<S.Element> {
    let _base: S
    
    override func makeIterator() -> AnyIterator<S.Element> {
        return AnyIterator(_base.makeIterator())
    }
}

protocol Shape {
    func draw() -> String
}

struct Circle: Shape {
    func draw() -> String { return "Circle" }
}

struct Square: Shape {
    func draw() -> String { return "Square" }
}

// some（不透明类型）：编译器知道具体类型是 Circle，可以静态派发
// 所有返回路径必须返回相同的具体类型
func makeSomeShape() -> some Shape {
    return Circle()
}

// any（存在类型）：运行时才确定具体类型，可以返回不同类型
func makeAnyShape() -> any Shape {
    if Bool.random() {
        return Circle()
    } else {
        return Square()
    }
}

// 泛型约束：同构集合（所有元素必须是同一具体类型），编译器可优化
func processAll<T: Shape>(_ items: [T]) {
    for item in items { print(item.draw()) }
}

// 存在类型：异构集合（元素可以是不同具体类型），有运行时开销
func processHeterogeneous(_ items: [any Shape]) {
    for item in items { print(item.draw()) }
}

struct ExistentialContainer {
    void* valueBuffer[3];           // 值缓冲区（24字节）
    TypeMetadata* type;             // 类型元数据指针
    WitnessTable* witnessTable;     // 协议见证表指针
};

// id可以指向任何对象
id anyObject = [[NSString alloc] initWithString:@"Hello"];
anyObject = [[NSNumber alloc] initWithInt:42];
anyObject = [[NSArray alloc] init];

// 运行时通过消息派发确定方法调用
[anyObject description];  // 有效，因为所有NSObject子类都响应description

// 声明一个只包含NSString的数组
NSMutableArray<NSString *> *stringArray = [NSMutableArray array];
[stringArray addObject:@"Hello"];

// 编译时警告，但运行时可以执行
// [stringArray addObject:@42];  // 警告：Incompatible pointer types

// 运行时类型信息被擦除
NSArray *rawArray = stringArray;  // 泛型信息丢失

// 类型擦除后可以存储不同类型
NSMutableArray *mixed = [NSMutableArray array];
[mixed addObject:@"string"];
[mixed addObject:@123];
[mixed addObject:[NSDate date]];

@protocol Drawable <NSObject>
- (void)draw;
@end

// 使用协议类型，具体类型被擦除
id<Drawable> drawable = [[Circle alloc] init];
drawable = [[Rectangle alloc] init];

// 只能调用协议定义的方法
[drawable draw];

@interface TypeErasedProxy : NSProxy

@property (nonatomic, strong) id target;

- (instancetype)initWithTarget:(id)target;

@end

@implementation TypeErasedProxy

- (instancetype)initWithTarget:(id)target {
    _target = target;
    return self;
}

// 返回目标对象的方法签名，告诉运行时如何构造NSInvocation
- (NSMethodSignature *)methodSignatureForSelector:(SEL)sel {
    return [self.target methodSignatureForSelector:sel];
}

// 将方法调用转发给目标对象
- (void)forwardInvocation:(NSInvocation *)invocation {
    [invocation invokeWithTarget:self.target];
}

@end

// 使用
NSString *string = @"Hello World";
TypeErasedProxy *proxy = [[TypeErasedProxy alloc] initWithTarget:string];
// proxy的类型是TypeErasedProxy，但可以响应NSString的所有方法
NSLog(@"%@", [proxy uppercaseString]); // 输出：HELLO WORLD

protocol Validator {
    associatedtype Value
    func validate(_ value: Value) -> Bool
}

struct EmailValidator: Validator {
    func validate(_ value: String) -> Bool {
        return value.contains("@")
    }
}

struct AgeValidator: Validator {
    func validate(_ value: Int) -> Bool {
        return value >= 0 && value <= 120
    }
}

// 使用类型擦除存储不同类型的验证器
class AnyValidator<T>: Validator {
    private let _validate: (T) -> Bool
    
    init<V: Validator>(_ validator: V) where V.Value == T {
        _validate = validator.validate
    }
    
    func validate(_ value: T) -> Bool {
        return _validate(value)
    }
}

let emailValidator = AnyValidator(EmailValidator())
let ageValidator = AnyValidator(AgeValidator())

protocol DataService {
    associatedtype Data
    func fetch() -> Data
}

class AnyDataService<T>: DataService {
    private let _fetch: () -> T
    
    init<S: DataService>(_ service: S) where S.Data == T {
        _fetch = service.fetch
    }
    
    func fetch() -> T {
        return _fetch()
    }
}

class ViewModel {
    let dataService: AnyDataService<[String]>
    
    init(dataService: AnyDataService<[String]>) {
        self.dataService = dataService
    }
}

// 优先使用泛型约束
func process<T: Drawable>(_ items: [T]) {
    for item in items {
        item.draw()
    }
}

// 必要时才使用存在类型
func processHeterogeneous(_ items: [any Drawable]) {
    for item in items {
        item.draw()
    }
}

// 推荐：使用协议约束
- (void)processItems:(NSArray<id<MyProtocol>> *)items {
    for (id<MyProtocol> item in items) {
        if ([item respondsToSelector:@selector(process)]) {
            [item process];
        }
    }
}

protocol Container {
    associatedtype Item
    func add(_ item: Item)
    func get(at index: Int) -> Item
}

// 编译错误：Protocol 'Container' can only be used as a generic constraint
// because it has Self or associated type requirements
let containers: [Container] = []

// 存在类型：animals 数组中每个元素的具体类型可以不同
// 编译器不知道每个元素到底是 Dog 还是 Cat，运行时通过见证表派发
var animals: [any Animal] = [Dog(), Cat()]

// 同一变量可以在不同时刻持有不同类型
var pet: any Animal = Dog()
pet = Cat()  // 合法

// 不透明类型：编译器知道返回的就是 Dog，但调用者只看到 "some Animal"
func makePet() -> some Animal {
    return Dog()
}

// 编译错误：所有返回路径必须返回相同的具体类型
func makeRandomPet() -> some Animal {
    if Bool.random() {
        return Dog()   // 返回 Dog
    } else {
        return Cat()   // 返回 Cat —— 类型不一致，编译失败
    }
}

struct ContentView: View {
    // some View：编译器知道 body 的具体类型是 VStack<TupleView<(Text, Button<Text>)>>
    // 但开发者不需要写出这个复杂类型，也不需要在每次修改 UI 时更新返回类型
    var body: some View {
        VStack {
            Text("Hello")
            Button("Tap") { }
        }
    }
}

protocol Shape {
    func area() -> Double
}

// 异构集合：Circle 和 Square 可以共存于同一数组
let shapes: [any Shape] = [Circle(radius: 5), Square(side: 3)]

// 动态返回不同类型
func randomShape() -> any Shape {
    Bool.random() ? Circle(radius: 1) : Square(side: 1)
}

// 泛型约束：所有元素必须是同一具体类型
// 调用 process([Circle(), Circle()]) 时，编译器为 Circle 生成专用版本
func process<T: Shape>(_ items: [T]) {
    for item in items {
        print(item.area())  // 特化后变为直接调用 Circle.area()，可内联
    }
}

// 这样调用会编译错误，因为 Circle 和 Square 不是同一类型
// process([Circle(radius: 5), Square(side: 3)])  // 错误

// 第一层：抽象基类，泛型参数只有 Element，没有具体的序列类型 S
internal class _AnySequenceBox<Element> {
    func makeIterator() -> AnyIterator<Element> { fatalError() }
    // Sequence 协议的其他方法要求...
}

// 第二层：具体 Box 子类，持有具体序列类型 S
internal final class _SequenceBox<S: Sequence>: _AnySequenceBox<S.Element> {
    let _base: S
    
    init(_ base: S) { self._base = base }
    
    override func makeIterator() -> AnyIterator<S.Element> {
        return AnyIterator(_base.makeIterator())
    }
}

// 第三层：公开的类型擦除包装器
public struct AnySequence<Element>: Sequence {
    internal let _box: _AnySequenceBox<Element>
    
    public init<S: Sequence>(_ base: S) where S.Element == Element {
        // 擦除发生在这里：_SequenceBox<Array<Int>> 向上转型为 _AnySequenceBox<Int>
        // 具体类型 Array<Int> 从类型签名中消失
        self._box = _SequenceBox(base)
    }
    
    public func makeIterator() -> AnyIterator<Element> {
        return _box.makeIterator()  // vtable 派发到子类的 override 实现
    }
}

struct ExistentialContainer {
    void* valueBuffer[3];       // 值缓冲区（24字节）
    TypeMetadata* type;         // 类型元数据指针
    WitnessTable* witnessTable; // 协议见证表指针
};

func process<T: Shape>(_ items: [T]) {
    for item in items {
        item.area()
    }
}

process([Circle(radius: 5), Circle(radius: 3)])  // 调用点：T = Circle

// 编译器自动生成（等价逻辑，非真实代码）
func process_Circle(_ items: [Circle]) {
    for item in items {
        item.area()  // 直接调用 Circle.area()，静态派发
    }
}