Identifiable as generic and func parameter

Question

Hello I want to build something like below:

protocol BaseEntity: Identifiable {
    var id: UUID { get set }
}

protocol DataStore {
    associatedtype T: BaseEntity
    
    typealias CompleteHandler<T> = ((Result<T, Error>) -> Void)

    func read(with id: T.ID, completion: CompleteHandler<T>)
}

but in concrete implementation I want to make use of the UUID that was defined in the BaseEntity protocol:

class Storage<Entity: BaseEntity>: DataStore {
    func read(with id: Entity.ID, completion: CompleteHandler<Entity>) {
        // here, how to use that id as a UUID?
    }
}

I don't know how to do it really, to define that there must be an object conforming to BaseEntity and would like to use that UUID id property in the concrete implementation. I don't want to do it like:

func read(with id: Entity.ID, completion: CompleteHandler<Entity>) {
    guard let uuid = id as? UUID else {
        return
    }
        
    // more code goes here...
}

How I should do it?

What is `Entity.ID`? I don't see how that's defined or how it could possibly compile. — matt, Nov 05 '22 at 19:52
Hello @matt `Entity` is just like a `T` on a generic constraint. — piotr_ch, Nov 05 '22 at 19:55
Should I just do that in concrete implementation?: `class JSONStorage: DataStore where Entity.ID == UUID {` — piotr_ch, Nov 05 '22 at 20:07
You're trying to conform the parameter `id` to a `Entity.ID` type. That type doesn't exist (i.e. isn't defined in your `BaseEntity` class). Do you want to just use 'BaseEntity` as the parameter type and then access its `id` parameter? — flanker, Nov 05 '22 at 20:28
Sorry, the proposed code is too nonsensical for me to guess what you're _really_ trying to do. You have all these `.ID` which seems to imply that these things have a subtype called `ID`. But I don't see anything that has such a type. For example, if a BaseEntity had an associated type called `ID` this would make more sense. But it doesn't. — matt, Nov 05 '22 at 20:59
`ID` is an `associatedtype` in the `Identifiable` protocol as far as I know. — gcharita, Nov 05 '22 at 21:08
yes the `Entity.ID` comes from `Identifable` protocol https://developer.apple.com/documentation/Swift/Identifiable — piotr_ch, Nov 05 '22 at 22:41

gcharita · Accepted Answer · 2022-11-05T21:35:28.730

Well, basically the lack of any concrete type in this implementation is what troubles the compiler to figure out the Entity.ID type.

This can be shown by not using a generic Entity type in your Storage implementation, like this:

struct MyEntity: BaseEntity {
    var id: UUID
}

class Storage: DataStore {
    func read(with id: MyEntity.ID, completion: CompleteHandler<MyEntity>) {
        print(id.uuidString) // <- `id` is of `UUID` type
    }
}

Solution 1: To help the compiler understand the Entity.ID type, you can conditionally conform to the DataStore protocol, by stating that Entity.ID will always be of UUID type (which is actually what you want in your implementation):

class Storage<Entity: BaseEntity>: DataStore where Entity.ID == UUID {
    func read(with id: Entity.ID, completion: CompleteHandler<Entity>) {
        print(id.uuidString) // again this line passes compilation
    }
}

Solution 2: Even better, you can conditional constraint your BaseEntity protocol by stating that ID will always be of UUID type. That way you do not need to change your Storage implementation:

protocol BaseEntity: Identifiable where ID == UUID {}
// or using the following which is also the same
protocol BaseEntity: Identifiable<UUID> {}

class Storage<Entity: BaseEntity>: DataStore {
    func read(with id: Entity.ID, completion: CompleteHandler<Entity>) {
        print(id.uuidString) // again this line passes compilation
    }
}

Solution 3: Another solution, which might be more appropriate in your context, is to convert BaseEntity to a class. That way you also do not need to change your Storage implementation:

class BaseEntity: Identifiable {
    var id: UUID
    
    init(id: UUID) {
        self.id = id
    }
}

class Storage<Entity: BaseEntity>: DataStore {
    func read(with id: Entity.ID, completion: CompleteHandler<Entity>) {
        print(id.uuidString) // again this line passes compilation
    }
}

Thanks you! I have found that Solution #1 works ok for me, but your solution #2 is even better! :) thanks again. — piotr_ch, Nov 05 '22 at 22:49

Identifiable as generic and func parameter

1 Answers1