在泛型类中使用泛型协议

我定义了一个协议LLNodeType:

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

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

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

为了符合LLNodeType因此，第一号议定书延长了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 method:

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.

The 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 method.

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

这是一个代码示例，仅包含与问题相关的部分：SwiftStub 代码 http://swiftstub.com/137821597/

问题是你的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...