associatedType inside another associatedType using protocols - swift

Question

I have been struggling to find a solution using generics and associated types inside another associated type for the problem above
Case
I want to have an ObjectRequestType, which inside it has an associated type of type ObjectResponseType.
protocol ObjectRequestType {
associatedtype Response: ObjectResponseType
}
ObjectResponseType on the other hand is a protocol having associated type Element
protocol ObjectResponseType {
associatedtype Element
}
What I want to achieve is that I want to extend the functionality of ObjectRequestType depending on different type of elements, that here for the sake of example we have two different types of Element.
protocol ElementType {}
protocol OtherElementType {}
So far I would implement this by the following extensions
extension ObjectRequestType where Response.Element: ElementType {
static func request() {
print("ElementType")
}
}
extension ObjectRequestType where Response.Element: OtherElementType {
static func request() {
print("OtherElementType")
}
}
The extra step would be to handle to pass this request to a class which I need using generics
class DemoClass<Request: ObjectRequestType> {
static func execute() {
Request.request()
}
}
Problem
Since on the fly DemoClass cannot define what kind of Response the Request has it will find two implementations of it, and it will fail throwing the compilation error
error: ambiguous reference to member 'request()'
Modifying the class by adding an extra where clause still won't do it, because I will miss the rest of the implementation of OtherElementType
class DemoClass<Request: ObjectRequestType> where Request.Response.Element: ElementType {
static func execute() {
Request.request()
}
}
I have been trying workarounds about it, but still I haven't been able to implement this kind of case. If anybody has any idea or another approach, it would be happily welcomed.

Answer 1

The usual way to do this is to add the request method to the ObjectResponseType protocol so you can guarantee that it exists on any conforming type. Then you create a protocol extension providing the default implementation for the types you know how to handle, which you've already done. If you need to override the request for a certain request with one of the existing element types, you can do that. If you need to support another element type, you can either do it right in the request or add another protocol extension.
protocol ObjectResponseType {
associatedtype Element
}
protocol ObjectRequestType {
associatedtype Response: ObjectResponseType
static func request()
}
protocol ElementType {}
extension ObjectRequestType where Response.Element: ElementType {
static func request() {
print("ElementType")
}
}
protocol OtherElementType {}
extension ObjectRequestType where Response.Element: OtherElementType {
static func request() {
print("OtherElementType")
}
}
class DemoClass<Request: ObjectRequestType> {
static func execute() {
Request.request()
}
}
class Foo: ElementType {}
class FooResponse: ObjectResponseType {
typealias Element = Foo
}
class FooRequest: ObjectRequestType {
typealias Response = FooResponse
}
class Bar: OtherElementType {}
class BarResponse: ObjectResponseType {
typealias Element = Bar
}
class BarRequest: ObjectRequestType {
typealias Response = BarResponse
// Override the default implementation
static func request() {
print("Bar")
}
}
class Baz {}
class BazResponse: ObjectResponseType {
typealias Element = Baz
}
class BazRequest: ObjectRequestType {
typealias Response = BazResponse
static func request() {
print("Baz")
}
}
DemoClass<FooRequest>.execute() // ElementType
DemoClass<BarRequest>.execute() // Bar
DemoClass<BazRequest>.execute() // Baz