Type 'T' does not conform to protocol 'EntityType' - swift

Question

I think the type relationships are rather plain here and yet I'm missing the cause for the error. The error is: "Type 'T' does not conform to protocol 'EntityType'" (at ThingManager):
//
protocol EntityType {
typealias Identifier
var identifier : Identifier { get }
}
class EntityWithStringIdentifier : EntityType {
var identifier : String
init (i:String) { self.identifier = i }
}
class Thing : EntityWithStringIdentifier {}
//
protocol EntityManager {
typealias Entity : EntityType
func has (entity:Entity) -> Bool
}
class BaseEntityManager<Entity:EntityType> : EntityManager {
func has (entity:Entity) -> Bool { return true }
}
// Type 'T' does not conform to protocol 'EntityType'
class ThingManager<T:Thing> : BaseEntityManager<T> {
}
T is a subtype of Thing; Thing is a subtype of EntityWithStringIdentifier which implements EntityType. So, why the error?
Apparently the error is avoidable by using:
class ThingManager<T:Thing where T:EntityType> : BaseEntityManager<T> {
}
and then one can instantiate a ThingManager with Thing (implying Thing implemented EntityType in the first place...)
var tm = ThingManager<Thing>()
From a type perspective, is there a better way to implement this kind of DAO pattern?

Answer 1

With the announcement of Swift 2.0, it seems pointless to answer this question in terms of earlier versions of Swift, which will very soon be obsolete. I can confirm that this problem—which I believe to be a bug—still exists as of this writing in Swift 2.0. However, I can suggest a slightly different way to organize the code that mitigates the problem while still having a clean implementation: Skip the ThingManager class and use a protocol extension instead.
So, leaving all your code the same up to BaseEntityManager, you'd have:
// NOTE "where Entity: Thing". This is the key.
extension EntityManager where Entity: Thing {
func useAThing(thing: Thing) {
}
}
let tm = BaseEntityManager<Thing>()
tm.useAThing(Thing(i: "thing"))
I suspect this will end up being the "Swift way" of doing things. Swift's generics are just plain strange to me. They constantly violate the Principle of Least Surprise, IMHO. But ultimately they are quite powerful if you learn their quirks. The only drawback of this approach is with access modifiers and encapsulation. The useAThing method has no access to the private state of EntityManagerBase, which may or may not be a problem depending on your circumstances.
Lastly, if you take this approach, I recommend some renaming. BaseEntityManager feels like the wrong name if you never subclass it. Instead, I would call it EntityManager and rename the protocol to EntityManagerType to follow Apple's conventions.