返回泛型时的 Swift 协议一致性

Question

Here's an example:

protocol Feed {
    func items<T>() -> [T]? where T: FeedItem
}

protocol FeedItem {}

class FeedModel: Feed, Decodable {
    func items<T>() -> [T]? where T : FeedItem {
        return [FeedItemModel]() // Error: Cannot convert return expression of type '[FeedItemModel]' to return type '[T]?'
    }
}

class FeedItemModel: FeedItem, Decodable {}

Why does it:

A) try to convert to T when T is a generic, not a type? B) does not recognize FeedItemModel as conforming to FeedItem ?

Answer 1

func items<T>() -> [T]? where T : FeedItem

This says that the caller can define T to be whatever they want, as long as T conforms to FeedItemModel, and this function will return an optional array of those.

FeedItemModel is something that conforms to FeedItem, but it is not promised to be the type T that the caller requested.

As an example, consider:

class OtherModel: FeedItem {}

According to your function signature, I can do this:

let ms: [OtherModel]? = FeedModel().items()

But your function won't then return [OtherModel]? to me. I suspect you don't actually mean this to be generic. I expect you mean:

func items() -> [FeedItemModel]?

or possibly

func items() -> [FeedItem]?

(Though I would think very hard before doing the latter one and make sure that the protocol existential is really doing useful work here.)

Answer 2

A)

T is a type, a homogenous concrete type specified at runtime.
Imaging T is class Foo: FeedItem it's obvious that FeedItemModel cannot be converted to Foo

B)

FeedItemModel is recognized as conforming to FeedItem but this is irrelevant.

---

It's often a mix-up of generics and protocols. Generic types are not covariant. If you need covariant types use an associated type.

Answer 3

Either you can ignore generics because because it only applies to that one function and it isn't needed since directly saying that the return type is [FeedItem]? yields the same result

protocol Feed {
    func items() -> [FeedItem]?
}

class FeedModel: Feed, Decodable {
    func items() -> [FeedItem]?  {
        return [OtherModel]()
    }
}

If you on the other hand want a generic protocol then you should use a associated type

protocol Feed2 {
    associatedtype T: FeedItem

    func items() -> [T]?
}

class FeedModel2: Feed2, Decodable {
    typealias T = FeedItemModel
    func items() -> [T]?  {
        return [FeedItemModel]()
    }
}