class - 为符合 'generate()' 的类的子类更改 'SequenceType' 方法

Question

假设我有一个通用类 Parent<P> , 符合 SequenceType 协议(protocol)，通过实现 generate() 方法:

class Parent<P> {
    //...
}

extension Parent: SequenceType {
    func generate() -> GeneratorOf<[P]> {
    //...

    return GeneratorOf<[P]> {
        //return the next element, or nil to stop
    }
}

现在 generate()方法显然不会简单地返回 P 类型的元素，但是 [P] .

现在让我们实现一个子类Child<C> :

class Child<C>: Parent<C> {
    //...
}

Child也应该符合 SequenceType , 但不应返回 [C] 类型的元素，而是 C .
从逻辑上讲，我会尝试实现自己的 generate()方法:

extension Child: SequenceType {
    func generate() -> GeneratorOf<C> {
    //...

    return GeneratorOf<C> {
        //return the next element, or nil to stop
    }
}

但这不起作用，swift 会抛出一个错误:

<stdin>: error: type 'Child<C>' does not conform to protocol '_Sequence_Type'
extension Child: SequenceType {
^
Swift._Sequence_Type: note: multiple matching functions named 'generate()' with type '() -> Child<C>.Generator'
func generate() -> Generator
^
<stdin>: note: candidate exactly matches [with Generator = GeneratorOf<C>]
func generate() -> GeneratorOf<C> {
^
<stdin>: note: candidate exactly matches [with Generator = GeneratorOf<[C]>]
func generate() -> GeneratorOf<[P]> {
^
<stdin>: error: type 'Child<C>' does not conform to protocol 'SequenceType'
extension Child: SequenceType {
^
Swift.SequenceType: note: multiple matching functions named 'generate()' with type '() -> Child<C>.Generator'
func generate() -> Generator
^
<stdin>: note: candidate exactly matches [with Generator = GeneratorOf<C>]
func generate() -> GeneratorOf<C> {
^
<stdin>: note: candidate exactly matches [with Generator = GeneratorOf<[C]>]
func generate() -> GeneratorOf<[P]> {

这里有什么问题，我该如何解决？

---

更新#1:

所以这个问题似乎可以通过应用@rintaro 只定义一个typealias 的方法来解决。对于 Generator在Child 类。
但正如@AirspeedVelocity 和@NateCook 在评论中所讨论的那样，这不是一个非常可行的方法，因为 Child class 也可以被子类化。

还指出可以创建一个实例属性(我假设是计算)返回所需元素的序列:

class Parent<P> {
    var asSequence: [[P]] {
        //some kind of getter
    }

    //...
}

class Child<C>: Parent<C> {
    override var asSequence: [C] {
        //some kind of getter
    }

    //...
}

实例 仍然可以在for-in-loops 中使用:

for element in someParent.asSequence {
    //element is of type [P]
}

for element in someChild.asSequence {
    //element is of type C
}

这会是“最佳”方法吗？

更新 #1.1:

正如@MichaelWelch 所建议的，属性 ( asSequence ) 的名称在这种情况下可能会造成混淆，因为它们返回不同的类型。
这似乎是合适的，但要视情况而定。但通常应避免歧义。

Answer 1

看来，你可以。 Generator 的显式类型别名仅在 Child 中起作用。但是，我也认为您不应该这样做...

class Parent<P> {
    var _src:[[P]] = []
}

extension Parent: SequenceType {

    func generate() -> GeneratorOf<[P]> {

        var g = _src.generate()

        return GeneratorOf<[P]> {
            return g.next()
        }
    }

}

class Child<C>: Parent<C> {
    var _ary:[C] = []
}

extension Child: SequenceType {

    typealias Generator = GeneratorOf<C> // <-- HERE

    func generate() -> GeneratorOf<C> {

        var g = _ary.generate()

        return GeneratorOf<C> {
            return g.next()
        }
    }
}