class - 在泛型类中使用泛型协议(protocol)

Question

我定义了一个协议(protocol) LLNodeType :

protocol LLNodeType {
    typealias T
    var firstNode: LLNode<T>? { get }
}

LLNode<T>只是一个简单的泛型类，它包含一个类型为 N 的存储属性.

class LLNode<N> {
    var content: N
    ...
}

为了符合LLNodeType因此我扩展了协议(protocol) LLNode如下:

extension LLNode: LLNodeType {
    typealias T = N

    var firstNode: LLNode<T>? {
        return self
    }
}

我还定义了一个泛型类 LLLinkedList包含一些使用通用类型的属性和函数 L :

class LLLinkedList<L> {
    var rootNode: LLNode<L>?
    ...
}

我扩展了这个类以符合 LLNodeType :

extension LLLinkedList: LLNodeType {
    typealias T = L

    var firstNode: LLNode<T>? {
         return self.rootNode
    }
}

我找到了一种传递 LLNodeType 的方法LLLinkedList 的方法作为常规类型并将其用于 append方法:

func append<NT: LLNodeType>(nodeSequence: NT) {
    let nodes = LLLinkedList(nodeSequence: nodeSequence) 
    ...
}

如 append 的第一条语句所示方法，我还为 LLLinkedList 定义了一个初始化程序, 它带有一个参数 nodeSequence类型 LLNodeType :

convenience init<NT: LLNodeType where NT.T == L>(nodeSequence: NT) {
    self.init()
    self.rootNode = nodeSequence.firstNode
}

初始化器只需要一个 nodeSequence符合 LLNodeType , 虽然使用类型 T 受到限制等于 L .

firstNode nodeSequence 的属性因此，符合这些条件应该返回 LLNode<L>?。 .

因此声明self.rootNode = nodeSequence.firstNode应该是完全可能的，因为self.rootNode类型为 LLNode<L>? .

---

当我尝试编译代码时，出现错误:

<stdin>:501:33: error: extra argument 'nodeSequence' in call
let nodes = LLLinkedList(nodeSequence: nodeSequence)

501:33指的是 append 的第一条语句方法。

怎么会有extra argument 'nodeSequence'如果我用一个名为 nodeSequence 的参数定义初始化程序？

---

这是一个代码示例，仅包含与问题相关的部分: SwiftStub-Code

Answer 1

问题是您的 append 函数没有为您追加的序列指定 LLNodeType.T 的类型:

func append<NT: LLNodeType>(nodeSequence: NT) {
    // here, nodeSequence could be of a String, an Int, who knows...
    let nodes = LLLinkedList(nodeSequence: nodeSequence) 
    ...
    // but here you try to append it to the existing list...
    // what if it's not a list of the same type?
    if self.isEmpty {
        self.rootNode = nodes.rootNode
    } else {
    /// appends a node by pointing the last nodes pointer ('nextNode' property) to the new node
        self.lastNode!.nextNode = nodes.rootNode
    }
}

你可以通过强制你只附加与你的相同类型的序列来解决这个问题

func append<NT: LLNodeType where NT.T == L>(nodeSequence: NT) {
    // etc...