Swift泛型约束问题：如何让BaseFooProtocol子协议作为泛型参数？

报错Only concrete types such as structs, enums and classes can conform to protocols的核心原因：Swift泛型参数必须是具体类型（结构体、枚举、类），而你直接传入了协议类型FooProtocol。协议只是定义了类型的行为规范，本身不是能实例化的具体类型，所以没法满足T: BaseFooProtocol的泛型约束。

实际上你的Foo<T: BaseFooProtocol>已经支持所有遵循BaseFooProtocol及其子协议的具体类型，只是使用方式不对。

方案1：传入具体类型（推荐） #

只要定义一个遵循FooProtocol的具体类型，就能正常作为泛型参数使用：

protocol BaseFooProtocol {
    var foo: String { get }
}

protocol FooProtocol: BaseFooProtocol {
    var bar: String { get }
}

// 定义遵循FooProtocol的具体结构体
struct ConcreteFoo: FooProtocol {
    var foo: String { "Concrete Foo" }
    var bar: String { "Concrete Bar" }
}

struct Foo<T: BaseFooProtocol> {
    func action(foo: T) {
        print(foo.foo)
    }
}

func test() {
    // 用具体类型作为泛型参数，编译正常
    let foo: Foo<ConcreteFoo> = .init()
    foo.action(foo: ConcreteFoo()) // 输出：Concrete Foo
}

方案2：使用存在类型（直接支持协议抽象） #

如果确实需要直接处理协议类型（不需要泛型的强类型约束），可以把泛型结构体改成接受存在类型any BaseFooProtocol：

protocol BaseFooProtocol {
    var foo: String { get }
}

protocol FooProtocol: BaseFooProtocol {
    var bar: String { get }
}

struct Foo {
    func action(foo: any BaseFooProtocol) {
        print(foo.foo)
    }
}

func test() {
    let foo: Foo = .init()
    // 可以传入任何遵循BaseFooProtocol或其子协议的实例
    let concreteFoo = ConcreteFoo()
    foo.action(foo: concreteFoo)
    
    // 也可以直接用协议类型的存在值
    let protocolValue: any FooProtocol = concreteFoo
    foo.action(foo: protocolValue)
}

方案3：泛型+类型擦除（兼顾泛型特性与协议抽象） #

如果想保留泛型的编译时检查优势，同时支持协议类型的抽象，可以用类型擦除包装器：

protocol BaseFooProtocol {
    var foo: String { get }
}

protocol FooProtocol: BaseFooProtocol {
    var bar: String { get }
}

// 类型擦除包装器，把任意BaseFooProtocol实例转为具体类型
struct AnyBaseFoo: BaseFooProtocol {
    private let _foo: () -> String
    
    init<T: BaseFooProtocol>(_ base: T) {
        _foo = { base.foo }
    }
    
    var foo: String { _foo() }
}

struct Foo<T: BaseFooProtocol> {
    func action(foo: T) {
        print(foo.foo)
    }
}

func test() {
    let concreteFoo = ConcreteFoo()
    // 用包装器把协议兼容的实例转为具体类型
    let erasedFoo: AnyBaseFoo = AnyBaseFoo(concreteFoo)
    let foo: Foo<AnyBaseFoo> = .init()
    foo.action(foo: erasedFoo) // 输出：Concrete Foo
}

• 优先用方案1：如果你需要强类型约束、编译时检查，以及泛型带来的性能优势；
• 选方案2：如果你需要最大的灵活性，允许传入任何符合协议的实例，不依赖具体类型；
• 选方案3：如果你既要保留泛型的特性，又需要处理协议抽象的场景。

内容的提问来源于stack exchange，提问作者William Hu