Generic class with reference to itself - swift

Question

I have the following classes in Swift:
class A {}; class B {}
class Collection<T> {
var parent: Collection?
}
When I want to build a hierarchy like
var rootCol = Collection<A>()
var childCol = Collection<B>()
childCol.parent = rootCol
The last line produces this error:
Cannot assign value of type 'Collection<A>' to type 'Collection<B>?'
What type does parent have to be, so that one can assign it with different generic types?

Answer 1

The problem is that you are trying to assign an instance of type Collection<A> to a variable of type Collection<B>? which is not possible , You can only assign Collection<A> to Collection<A> or Collection<B> to Collection<B>.
Although your aren't writing <T> at the end of the parent type but swift infers that to be of the type Collection<T> and then also optional.
In This case I would recommend using protocol.
One more thing,it's advisable to NOT use names for classes that conflict with swift protocols.
class A {}
class B {}
protocol Foo{}
class Bar<T>:Foo {
var parent: Foo?
}
var rootCol = Bar<A>()
var childCol = Bar<B>()
childCol.parent = rootCol

Answer 2

Your structure can either be a tree of "containers" using a generic class based on the contained data (which can work on both reference and value types).
For example:
class TreeOf<T>
{
var value:T? = nil
weak var parent:TreeOf<T>? = nil
var children:[TreeOf<T>] = []
init(_ value:T? = nil)
{ self.value = value }
func addChild(_ value:T) -> TreeOf<T>
{
let newNode = TreeOf<T>()
newNode.value = value
children.append(newNode)
return newNode
}
}
var directory = TreeOf<String>("/")
directory.addChild("usr")
directory.addChild("library")
let users = directory.addChild("users")
users.addChild("paul")
users.addChild("John")
users.addChild("Mary")
let userNames = directory.children[2].children.map{$0.value}
Or your tree nodes themselves (i.e. the objects that are linked in the tree structure) can implement the linking variables and use a common protocol to obtain all the tree manipulation functionality for free. This however, only works on reference types and requires a final class.
For example:
protocol TreeNode:class
{
var parent :Self? { get set }
var children :[Self] { get set }
}
extension TreeNode
{
func removeFromParent()
{
parent?.children = parent!.children.filter{$0 !== self}
parent = nil
}
func childOf(_ newParent:Self) -> Self
{
removeFromParent()
parent = newParent
newParent.children.append(self)
return self
}
// ... more generic tree related functions provided by protocol for all classes
// e.g. root, count descendants, searches, traversal, prune and graft, etc.
}
final class FamilyMember:TreeNode
{
var parent:FamilyMember? = nil
var children:[FamilyMember] = []
var name = ""
init(_ newName:String) {name = newName}
}
let paul = FamilyMember("Paul")
let mary = FamilyMember("Mary").childOf(paul)
let john = FamilyMember("John").childOf(paul)
let suzie = FamilyMember("Suzie").childOf(mary)
let luke = FamilyMember("Luke").childOf(mary)
let irene = FamilyMember("Irene").childOf(john)
let miniPaul = paul.children.map{$0.name}
let miniMary = mary.children.map{$0.name}