如何解决Identifier类型CustomStringConvertible的重叠一致性问题

你遇到的核心问题是：分别为String和Int版本的Identifier添加CustomStringConvertible一致性时，要么其中一个实现不生效，要么触发编译器的重叠冲突报错。这里有两个简洁优雅的解决方案，你可以根据需求选择：

方案一：让RawIdentifier默认遵循CustomStringConvertible（推荐） #

既然String和Int本身都已经遵循了CustomStringConvertible，我们可以直接修改Identifiable协议，要求关联类型RawIdentifier同时遵循这个协议，这样就能统一处理所有类型的打印需求：

protocol Identifiable {
    // 新增CustomStringConvertible约束，默认类型仍为String
    associatedtype RawIdentifier: Codable, Hashable, CustomStringConvertible = String
    var id: Identifier<Self> { get }
}

struct Identifier<Value: Identifiable>: Hashable {
    let rawValue: Value.RawIdentifier
    init(stringLiteral value: Value.RawIdentifier) {
        rawValue = value
    }
}

// 统一实现CustomStringConvertible，无需分类型写扩展
extension Identifier: CustomStringConvertible {
    var description: String {
        rawValue.description
    }
}

// 保留原有的ExpressibleByIntegerLiteral扩展
extension Identifier: ExpressibleByIntegerLiteral where Value.RawIdentifier == Int {
    typealias IntegerLiteralType = Int
    init(integerLiteral value: IntegerLiteralType) {
        rawValue = value
    }
}

这种方式的优势是扩展性极强，以后如果你的RawIdentifier需要支持其他类型（比如UUID、UInt），只要该类型本身遵循CustomStringConvertible，就不需要修改Identifier的代码，自动支持正确的打印输出。

方案二：使用互斥的条件扩展实现CustomStringConvertible #

如果你不想修改Identifiable协议的约束，也可以通过精准的where子句，为不同RawIdentifier类型的Identifier分别实现CustomStringConvertible。这两个扩展的约束完全互斥，编译器会正确识别并匹配对应的实现，不会产生冲突：

// 保留原有的Identifiable和Identifier定义
protocol Identifiable {
    associatedtype RawIdentifier: Codable, Hashable = String
    var id: Identifier<Self> { get }
}

struct Identifier<Value: Identifiable>: Hashable {
    let rawValue: Value.RawIdentifier
    init(stringLiteral value: Value.RawIdentifier) {
        rawValue = value
    }
}

extension Identifier: ExpressibleByIntegerLiteral where Value.RawIdentifier == Int {
    typealias IntegerLiteralType = Int
    init(integerLiteral value: IntegerLiteralType) {
        rawValue = value
    }
}

// 分别为String和Int类型的RawIdentifier实现CustomStringConvertible
extension Identifier: CustomStringConvertible where Value.RawIdentifier == String {
    var description: String {
        rawValue
    }
}

extension Identifier: CustomStringConvertible where Value.RawIdentifier == Int {
    var description: String {
        "\(rawValue)"
    }
}

你之前遇到的“重叠问题”大概率是因为写法有误（比如存在不带约束的CustomStringConvertible扩展），上面的两个扩展约束完全互斥，编译器会正确匹配对应的实现。

测试效果 #

用以下代码验证两种方案的输出：

struct A: Identifiable {
    typealias RawIdentifier = String
    var id: Identifier<A>
}

struct B: Identifiable {
    typealias RawIdentifier = Int
    var id: Identifier<B>
}

print(Identifier<A>(stringLiteral: "string")) // 输出 "string"
print(Identifier<B>(integerLiteral: 5)) // 输出 "5"

两种方案都能让Identifier直接打印出原始值，而非默认的结构体描述。

内容的提问来源于stack exchange，提问作者Adam Bardon