How to conform to a protocol with a generic superscript affordance in Swift?

TL;DR How can I conform to the supscript function of a protocol in my implementation?

Protocol:

protocol DataStore {
    //...
    subscript<T>(id: T.ID) -> T where T: Identifiable { get set }
}

Neither

subscript<T>(id: T.ID) -> T where T : Identifiable {
        get { Project() }//just to return anything for the time being…
        set {}
    }

nor

subscript(id: Task.ID) -> Task {
        get { Project() }//just to return anything for the time being…
        set {}
    }

work...

The details:

I have developed a habit of creating specific data stores for my models. They all have the same functionality. A specific example could look like this:

final class ProjectDataStore: ObservableObject {
    {
        static let shared = ProjectDataStore()
        
        let persistence = AtPersistLocally.shared // that's from a personal package I made that handles saving and loading locally as json files
        
        @Published var projects: [Project] {
            didSet { //save }
        }
        
        private init(projects: [Project]? = nil) {
            //load from persistence
        }
        
        subscript(id: Project.ID) -> Project? {
            get { //return project with id }
            set { //set project at id }
        }
        
        func getBinding(by id: Project.ID) -> Binding<Project> {
            //return Binding
        }
        
        func getProjectBy(taskId: Task.ID) -> Project {
            //return instance
        }
        
        private func getIndex(by id: Project.ID) -> Int? {
            //return  index in array
        }
        
        private func load() -> [Project] {
            //load from persistence
        }
        
        private func save() {
            //save from persistence
        }
}

While this works as expected, I'd like to be able to introduce a protocol that I could when adding new functionality / models to have a blueprint on what's necessary for my DataStore.

Here is my first attempt:

protocol DataStore {
    static var shared: Self { get }
}

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

To also conform to ObservableObject, I introduce a typealias

typealias ObservableObjectDataStore = DataStore & ObservableObject

and change my model to conform to this new typealias:

final class ProjectDataStore: ObservableObjectDataStore {
//...
}

With this, I already have a static instance and access to persistence available. Next step of course is to move more and more properties to the protocol–which is what I am struggling with right now.

Let's look at superscript first of all: I guess I understand what needs to be added to the protocol:

protocol DataStore {
    //...
    subscript<T>(id: T.ID) -> T where T: Identifiable { get set }
}

My problem now is that I don't know how to go about conforming to this subscript now while also getting access to a concrete model from the generic T from the implementation. This attempt…

final class ProjectDataStore: ObservableObjectDataStore {
    //...
    subscript<T>(id: T.ID) -> T where T : Identifiable {
        get { Project() }//just to return anything for the time being…
        set {}
    }
}

…leads to the error message Cannot convert return expression of type 'Task' to return type 'T'.

If I go with…

final class ProjectDataStore: ObservableObjectDataStore {
    //...
    subscript(id: Task.ID) -> Task {
        get { Project() }//just to return anything for the time being…
        set {}
    }
}

…the error message changes to Type 'TaskDataStore' does not conform to protocol 'DataStore'.

So I guess basically what I am asking is: how can I conform to my protocol's generic superscript in my implementation of ProjectDataStore?

I have a feeling that I am not too far of, but a critical info is obviously missing…