Overriding property with generic type of generic base class

Question

Here is what I want to do: protocol GenericFactory { associatedtype Input associatedtype Value func create(with input: Input) -> Value } class Base { var input: Factory.Input { preconditionFailure("To be overriden") } } protocol ValueProtocol {} struct SomeInputImpl {} protocol ValueFactory: GenericFactory where Input == SomeInputImpl, Value: ValueProtocol {} class Child: Base { override var input: Factory.Input { return SomeInputImpl() } } On the line swift override var input: Factory.Input { I'm getting an error Property 'input' with type 'SomeInputImpl' cannot override a property with type 'Factory.Input'. I do not understand the reason of this error as the type of input is described in ValueFactory protocol, but because of some reasons swift interprets the Factory.Input in base and Factory.input in Child as different types. Can someone please explain me what's wrong here? JavaScript questions and answers, JavaScript questions pdf, JavaScript question bank, JavaScript questions and answers pdf, mcq on JavaScript pdf, JavaScript questions and solutions, JavaScript mcq Test , Interview JavaScript questions, JavaScript Questions for Interview, JavaScript MCQ (Multiple Choice Questions)

Answer 1

Just to complete the point about this being addressed in Swift 5, here is the demonstration that will work in Swift 5, but not in Swift 4.2, given your example code. struct Val: ValueProtocol {} struct VF: ValueFactory { func create(with input: SomeInputImpl) -> Val { return Val() } } let child = Child() child.input // SomeInputImpl But you would almost certainly be better off using functions rather than GenericFactory. The main reason for the Factory pattern is to deal with languages that lack higher-order functions and first-class types, such as pre-8 Java. In languages with higher-order functions and first-class types (like Swift), the Factory pattern is typically unnecessary. You can just pass the function (Input) -> Value directly. Your example doesn't show the caller, so it's hard to know precisely what function-based solution will work best, but in most cases, generic functions are a much better approach than protocols+associatedType+generics+inheritance. In particular, mixing class inheritance into associated types tends to get you into bad corners (because associated types and class inheritance are somewhat orthogonal approaches to polymorphism).