Circular dependency within generic Swift classes - swift

Question

I have generic Parent and Child classes that should both be able to reference each other:
class Parent<MyChild: Child<Parent<MyChild>>> {
var children = [MyChild]()
}
class Child<MyParent: Parent<Child<MyParent>>> {
var parent: MyParent?
}
I want to be able to create subclasses of Parent and Child that have a reference to each other. The generics should allow each class to use methods of the other custom class as well as those inherited by the base Parent and Child classes, which may refer to the custom generics. EDIT: I need not only to reference methods, but instance variables as well.
This may be comparable to an array (the parent) having a reference to the children and each child having a reference to the array it belongs to. The array would be modelled with a generic Child type, and the child should then be modelled with a generic Parent type.
This code produces the compiler error Generic class 'Parent' references itself. I think this is possible in Java. Is there a way of expressing such a generic relationship in Swift?

Answer 1

You can use protocols to define the relationship between these types and the dependencies between them (with an associated type with generic where clause):
protocol Parent: AnyObject {
associatedtype C: Child where C.P == Self
var children: [C] { get set }
}
protocol Child: AnyObject {
associatedtype P: Parent where P.C == Self
var parent: P? { get }
}
(As an aside, I made these AnyObject because this doubly-linked pattern requires that you are dealing with reference types. Also, I made parent property optional because it will need to be weak to avoid strong reference cycles.)
Then the actual parent and child classes can use these protocols:
class Teacher: Parent {
var name: String
var socialSecurityNumber: String
var children: [Student] = []
}
class Student: Child {
var name: String
var admissionDate: Date
weak var parent: Teacher?
...
}
Again, note that parent is a weak property to avoid strong reference cycle.
Note, when using protocols, rather than having abstract (i.e., pure virtual) Child and Parent classes, we have protocol, and our concrete classes would conform to those protocol. And if we wanted to define methods that all of these conforming classes would share, we would define default implementations in a protocol extension. See WWDC 2015 video on Protocol Oriented Programming.