Make LinkedList Generic in Swift - swift

Question

Consider a Generically constructed Node for a DoublyLinkedList:
public class Node<T> {
var value: T
var next: Node<T>?
weak var previous: Node<T>?
init(value: T) {
self.value = value
}
}
public class DoublyLinkedList<T> {
var head: Node<T>?
private var tail: Node<T>?
public func append(value: T) {
let newNode = Node(value: value)
if let tailNode = tail {
newNode.previous = tailNode
tailNode.next = newNode
} else {
head = newNode
}
tail = newNode
}
....
How do I make the DoublyLinkedList even more Generic?
(i.e. I subclassed Node so that I could implement some specific behaviors via inheritance). I can't seem to synthesize a DoublyLinkedList of my subclass because it is looking for the "Concrete"? type of Node
class TransactionFilterNode: Node<Search> {
let seedTransactions: [Transaction]
init(search: Search, allTransactions: [Transaction]){
self.seedTransactions = allTransactions
super.init(value: search)
}
I can't seem to get this to be inserted or appended to DoublyLinkedList because DoublyLinkedList is looking for a Node, not a subclass of Node.
Edit: Solved
The solution was to pull the call for Node into the function call parameter so that I could pass a subclassed version. See below.

Answer 1

So your append method expects a type T (which in your case is Search), while you are directly subclassing a Node.
So you can
Option 1: create append that accepts the Node, e.g.:
func append(value: T) {
let newNode = Node(value: value)
append(newNode: newNode)
}
func append(newNode: Node<T>) {
if let tailNode = tail {
newNode.previous = tailNode
tailNode.next = newNode
} else {
head = newNode
}
tail = newNode
}
So now you can
let x = DoublyLinkedList<Search>()
let y = TransactionFilterNode(...)
x.append(newNode: y) // No problem
Option 2: subclass Search instead of subclassing Node
I.e. maybe instead of class TransactionFilterNode: Node<Search> you meant to say class TransactionFilter: Search?

Answer 2

My doubly linked list is generic over everything because I conceal Node from the user by embedding it.
He simply asks for a BiLinkedList or a BiLinkedList or whatever he wants to list. Only access via subscripts requires his objects to be Equatable. Note that all references to Node are private.
Here are my headers:
public struct BiLinkedList<Element> {
var head: Node<Element>?
var tail: Node<Element>?
public init(_ array: [Element] = []) {}
private mutating func copyNodes() {}
public var peekFirst: Element? { get }
public var peekLast: Element? { get }
public mutating func push(_ element: Element)
public mutating func append(_ element: Element)
public mutating func pop() -> Element?
public mutating func removeLast() -> Element?
}
extension BiLinkedList {
class Node<Element> {
var element: Element
weak var previous: Node?
var next: Node?
init(_ element: Element, previous: Node? = nil, next: Node? = nil)
}
}
extension BiLinkedList where Element: Equatable {
private func firstNode(containing value: Element) -> Node<Element>?
private func lastNode(containing value: Element) -> Node<Element>?
public mutating func insert(_ element: Element, beside value: Element, before: Bool) -> Bool
}
extension BiLinkedList {
public mutating func removeFirst(_ value: Element) -> Bool
public mutating func removeLast(_ value: Element) -> Bool
public mutating func removeAll(_ value: Element)
public mutating func replaceFirst(_ element: Element, with value: Element) -> Bool
public mutating func replaceLast(_ element: Element, with value: Element) -> Bool
}
extension BiLinkedList: Collection {
public struct Index: Comparable {
var node: Node<Element>?
public static func == (lhs: Index, rhs: Index) -> Bool {}
static public func <(lhs: Index, rhs: Index) -> Bool {}
}
public var startIndex: Index
public var endIndex: Index
public func index(after i: Index) -> Index {}
public subscript(position: Index) -> Element {}
public subscript(position: Int) -> Element? {}
}
extension BiLinkedList: Sequence {
public func makeIterator() -> LinkedListIterator {}
public struct LinkedListIterator: IteratorProtocol {
private var currentNode: Node<Element>?
fileprivate init(node: Node<Element>?) {}
public func next() -> Element? {}
}
}