Swift中如何为支持联合类型的属性包装器实现静态类型安全？

这个问题问得很精准！Swift确实没有原生的“只能是A或B”这种联合类型泛型约束，但咱们可以通过私有协议约束+条件泛型扩展的组合方式，既实现静态类型安全（编译时就拦截非法类型），又完全隐藏背后的枚举实现细节，完美满足你的需求。

第一步：用私有协议锁定允许的类型 #

首先咱们创建一个私有协议，只让Int和String遵守它。因为协议是私有的，外部代码无法给其他类型（比如Double）扩展这个协议，从根源上保证只有指定类型能被使用：

fileprivate protocol IntOrStringCompatible {}
extension Int: IntOrStringCompatible {}
extension String: IntOrStringCompatible {}

第二步：隐藏底层枚举实现 #

把你原来的IntOrString枚举设为私有，这样对外完全看不到这个实现细节：

fileprivate enum IntOrString {
    case int(Int)
    case string(String)
}

第三步：实现带类型约束的属性包装器 #

让Managed的泛型参数T必须遵守上面的私有协议，这样编译时就会直接阻止非法类型（比如Double）的使用，彻底避免运行时崩溃。

这里有两种实现方式，你可以根据需求选择：

方式一：优雅的条件扩展写法（无强制转换）

通过针对T == Int和T == String的条件扩展，分别处理不同类型的读写逻辑，完全避免不安全的强制转换，代码更健壮：

@propertyWrapper
struct Managed<T: IntOrStringCompatible> {
    private var storage: IntOrString
    
    var wrappedValue: T {
        get { getWrappedValue() }
        set { setWrappedValue(newValue) }
    }
    
    init(wrappedValue: T) {
        self.storage = Self.makeStorage(from: wrappedValue)
    }
    
    // 定义占位方法，由具体类型的扩展实现
    private func getWrappedValue() -> T { fatalError("需要为具体类型实现此方法") }
    private mutating func setWrappedValue(_ value: T) { fatalError("需要为具体类型实现此方法") }
    private static func makeStorage(from value: T) -> IntOrString { fatalError("需要为具体类型实现此方法") }
}

// 针对Int类型的扩展
extension Managed where T == Int {
    private func getWrappedValue() -> Int {
        guard case .int(let value) = storage else { fatalError("存储类型不匹配") }
        return value
    }
    
    private mutating func setWrappedValue(_ value: Int) {
        storage = .int(value)
    }
    
    private static func makeStorage(from value: Int) -> IntOrString {
        .int(value)
    }
}

// 针对String类型的扩展
extension Managed where T == String {
    private func getWrappedValue() -> String {
        guard case .string(let value) = storage else { fatalError("存储类型不匹配") }
        return value
    }
    
    private mutating func setWrappedValue(_ value: String) {
        storage = .string(value)
    }
    
    private static func makeStorage(from value: String) -> IntOrString {
        .string(value)
    }
}

方式二：简洁版实现（安全的强制转换）

如果觉得条件扩展有点繁琐，也可以直接在读写方法中做类型判断。由于有私有协议的约束，这里的强制转换是100%安全的，不会出现运行时错误：

@propertyWrapper
struct Managed<T: IntOrStringCompatible> {
    private var storage: IntOrString
    
    var wrappedValue: T {
        get {
            switch storage {
            case .int(let value): return value as! T
            case .string(let value): return value as! T
            }
        }
        set {
            if let intVal = newValue as? Int {
                storage = .int(intVal)
            } else if let stringVal = newValue as? String {
                storage = .string(stringVal)
            } else {
                // 由于协议约束，这里永远不会执行到
                fatalError("不支持的类型")
            }
        }
    }
    
    init(wrappedValue: T) {
        if let intVal = wrappedValue as? Int {
            storage = .int(intVal)
        } else if let stringVal = wrappedValue as? String {
            storage = .string(stringVal)
        } else {
            fatalError("不支持的初始类型")
        }
    }
}

验证效果 #

现在当你尝试把@Managed用在Double类型上时，编译器会直接报错：Type 'Double' does not conform to protocol 'IntOrStringCompatible'，完全避免了运行时崩溃。而合法的类型使用起来和普通属性毫无区别：

struct Foo {
    @Managed var intValue: Int = 42
    @Managed var stringValue: String = "Hello"
}

var foo = Foo()
foo.intValue = 100
foo.stringValue = "World"
print(foo.intValue) // 输出 100
print(foo.stringValue) // 输出 World

总结 #

• 通过私有协议+泛型约束，我们实现了静态类型安全，编译阶段就拦截非法类型，彻底解决了原方案的运行时崩溃问题。
• 底层枚举设为私有，完全隐藏实现细节，用户只需要直接使用Int或String类型的属性，感知不到背后的枚举存在。
• 两种实现方式各有优劣：条件扩展写法更优雅健壮，简洁版则更易理解实现。

备注：内容来源于stack exchange，提问作者tierriminator