Swift中如何遵循带泛型下标的DataStore协议？

问题背景 #

我习惯为每个模型创建专属的数据存储类，功能逻辑一致。现在希望通过DataStore协议统一规范这些存储类的接口，但在实现协议定义的泛型下标时遇到了问题：协议要求的泛型下标无法和具体模型的存储逻辑匹配，两种尝试均报错。

协议定义与无效实现 #

协议定义 #

我最初定义的协议包含一个泛型下标：

protocol DataStore {
    static var shared: Self { get }
    subscript<T>(id: T.ID) -> T where T: Identifiable { get set }
}

两种无效实现 #

• 方式一：直接实现泛型下标
  尝试返回具体模型实例时，编译器报错：Cannot convert return expression of type 'Project' to return type 'T'

  subscript<T>(id: T.ID) -> T where T : Identifiable {
      get { Project() } // 临时返回任意值
      set {}
  }
  

• 方式二：实现针对具体模型的下标
  编译器报错：Type 'ProjectDataStore' does not conform to protocol 'DataStore'，因为没有实现协议要求的泛型下标

  subscript(id: Project.ID) -> Project {
      get { Project() } // 临时返回任意值
      set {}
  }
  

解决方案：使用关联类型绑定具体模型 #

问题核心在于：你的每个DataStore子类只负责单一特定模型的存储（比如ProjectDataStore只处理Project），但原协议的泛型下标要求实现类能处理所有Identifiable类型，这两者逻辑矛盾。

正确的做法是给协议添加关联类型，让协议与具体的模型类型绑定：

1. 修改协议定义 #

protocol DataStore {
    // 关联当前存储类负责的模型类型，必须遵循Identifiable
    associatedtype Model: Identifiable
    
    static var shared: Self { get }
    // 下标改为针对关联的Model类型
    subscript(id: Model.ID) -> Model? { get set }
}

// 保留原有的ObservableObject组合类型别名
typealias ObservableObjectDataStore = DataStore & ObservableObject

2. 实现具体的存储类 #

以ProjectDataStore为例，指定关联的Model为Project，然后实现针对Project.ID的下标：

final class ProjectDataStore: ObservableObjectDataStore {
    // 明确协议关联的模型类型
    typealias Model = Project
    
    static let shared = ProjectDataStore()
    
    let persistence = AtPersistLocally.shared
    @Published var projects: [Project] {
        didSet { save() }
    }
    
    private init(projects: [Project]? = nil) {
        self.projects = projects ?? load()
    }
    
    // 实现协议要求的下标
    subscript(id: Project.ID) -> Project? {
        get {
            projects.first { $0.id == id }
        }
        set {
            guard let newValue = newValue, 
                  let index = projects.firstIndex(where: { $0.id == id }) else {
                return
            }
            projects[index] = newValue
        }
    }
    
    // 原有方法保持不变
    func getBinding(by id: Project.ID) -> Binding<Project> {
        // 你的Binding实现逻辑
    }
    
    private func load() -> [Project] {
        // 从持久化加载的逻辑
    }
    
    private func save() {
        // 持久化保存的逻辑
    }
}

3. 扩展协议添加通用逻辑 #

你可以在协议扩展中添加所有存储类通用的属性/方法，比如统一的持久化工具访问：

extension DataStore {
    var persistence: AtPersistLocally {
        AtPersistLocally.shared
    }
}

为什么这个方案可行？ #

通过关联类型Model，协议不再要求实现类处理任意Identifiable类型，而是只需要处理自己绑定的特定模型。这样每个存储类的下标实现完全匹配自身的业务逻辑，同时满足协议的规范要求，编译器也不会再报错。

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