Swift generics for graph classes - swift

Question

I'm trying to create some classes in Swift 5 to represent a directed Graph. I'm finding Swift generics to be very confusing and restrictive.
This is what I've got so far, but no matter what I try, Swift seems to come up with some obscure error or other (two are shown below in comments).
Can I even achieve this kind of structure in Swift without hardcoding Node to a specific concrete type?
I want to allow the Node type to be changed, so that I can add additional properties to the Node and Edge types according to the needs of the problem.
public class Graph<N:Node>
{
var nodeMap: [String: N] = [:]
var edges: [Edge<N>] = []
public func addEdge(_ parentName: String, _ childName: String, weight: Double = 0.0) throws {
let parent:N? = nodeMap[parentName]
let child:N? = nodeMap[childName]
let newEdge = Edge(parent!, child!)
parent!.outgoing.append(newEdge) // Cannot convert value of type 'Edge<N>' to expected argument type 'Edge<Node>'
edges.append(newEdge)
}
}
public class Edge<N:Node> {
var parent: N
var child: N
init(_ parent: N, _ child: N) {
self.parent = parent
self.child = child
}
}
public class Node {
var name:String = ""
var outgoing:[Edge<Self.Type>] = [] //'Edge' requires that 'Self.Type' inherit from 'Node'
}

Answer 1

I guess I'm a bit late to the party but for any future readers, the Final "issue" can be solved by making the Edge a protocol as well:
protocol Edge: class {
associatedtype NodeType: Node where NodeType.EdgeType == Self
var parent: NodeType {get set}
var child: NodeType? {get set}
}
To make sure any classes implementing these protocols actually point to the correct counterpart I've added a type constraint on the associatedtype.
protocol Node: class {
associatedtype EdgeType: Edge where EdgeType.NodeType == Self
var name:String {get set}
var outgoing:[EdgeType] {get set}
}
Just be careful of strong reference cycles as pointed out earlier. Hence the optional type of Edge.child to allow it to be weak. The reference arrangement can off course be different.
The main caveat of this method is that any subclasses to classes implementing these protocols will have properties pointing to their superclass. A proposed solution would be to not subclass but implement the protocols directly on the new class instead.

Answer 2

I think you need to make Node a protocol:
public protocol Node : class {
var name:String { get set }
var outgoing:[Edge<Self>] { get set }
}
Then, you can create concrete Node conformers that you can use as the generic argument for graph. e.g.
final public class ConcreteNode: Node {
public var name = ""
public var outgoing: [Edge<ConcreteNode>] = []
}
And you can create a Graph<ConcreteNode>. If you want to have a node with a foo property, you can create that class too:
final public class NodeWithFoo: Node {
public var name = ""
public var outgoing: [Edge<NodeWithFoo>] = []
public var foo = ""
}
And you can have another Graph<NodeWithFoo>.

Answer 3

Thanks for the responses.
The real end goal of this was to have Node and Edge types that could be specialized with additional fields to suit the application.
Sweeper's answer was a good answer to the specific implementation I posted in the question, and I learned a lot from it, so thanks for that.
However, what I ended up going with didn't use generics at all. This is what I did instead:
public class Node {
var name:String = ""
var outgoing:[Edge] = []
// Added this catchall property here
var data: Any?
}
I did a similar thing in the Edge class.
Now when I want to add some data to a Node, like say the price of an item as a Double field for example, I can simply create an extension like this:
extension Node {
var price:Double? {
get {
return self.data as? Double
}
set {
self.data = newValue
}
}
}
If I need to add more fields, I can always wrap them in a struct or class and set that via the extension.