Swift 斯威夫特不能'；当我试图提供自己的AnySequence实现时，我无法推断泛型类型

问题是，当一个协议通过其关联的类型依赖于另一个协议时，编译器无法推断泛型类型

所以，我在玩斯威夫特的类型擦除技术，试图熟悉它的想法。基本上，在我进入序列协议之前，这是可以理解的。已知它有一个关联的类型-迭代器，它符合迭代器协议。也就是说，我一直在尝试在自己的实现中实现类似的行为。我就是这么做的：

final类CustomAnySequence:Sequence{
类CustomAnyIterator:IteratorProtocol{
private let _next:（）->元素？
init（iterator:I），其中I.Element==Element{
变量迭代器=迭代器
_next={iterator.next（）}
}
func next（）->元素{
返回_next（）
}
}
typealias迭代器=CustomAnyIterator
typealias元素=迭代器.Element
私有let_makeIterator:（）->迭代器
init（u序列：S），其中S.Iterator==Iterator{
_makeIterator=sequence.makeIterator
}
func makeIterator（）->迭代器{
返回_makeIterator（）
}
}
let sequence=CustomAnySequence（[1,2,3]）

因此，最后一行给出了以下错误：无法推断通用参数“Element”

然后，如果我试图通过显式指定元素类型来修复它：

let sequence=CustomAnySequence（[1,2,3]）

这并没有让它变得更好。下一个Xcode问题是：无法推断通用参数“S”

这是我的错，还是斯威夫特的类型推断的开销太大？

实际上，我遇到了另一个可能的实现——它使用私有子类包装。我真的不喜欢它（这就是为什么我试着自己去做），因为在超类的实现中有“致命错误必须子类化”的方法，这不利于干净的代码。此外，我不确定如何通过CustomAnySequence的初始值设定项实现此功能（我发现只有通过创建静态方法才有可能实现）。尽管如此，这就是代码：

class CustomAnySequence:Sequence{
类迭代器：迭代器协议{
func next（）->元素{
fatalError（“必须被覆盖”）
}
}
func makeIterator（）->迭代器{
fatalError（“必须被覆盖”）
}
}
私有最终类CustomAnySequence实现：CustomAnySequence{
最终类迭代器实现：迭代器{
var-wrapped:S.Iterator
init（uuwrapped:S.Iterator）{
自我包装
}
重写func next（）->S.元素{
return wrapped.next（）
}
}
var序列：S
初始化（u序列：S）{
self.sequence=序列
}
重写func makeIterator（）->IteratorImplementation{
返回迭代器实现（sequence.makeIterator（））
}
}
扩展CustomAnySequence{
静态func make（sequence:S）->CustomAnySequence，其中S.Element==Element{
返回CustomAnySequenceImplementation（序列）
}
}
func printInts（uSequence:CustomAnySequence）{
对于序列中的元素{
打印（元素）
}
}
printInts（CustomAnySequence.make（[1,2,3]））
printInts（CustomAnySequence.make（Set（[4,5,6]））

---

实际上，它确实可以工作，但看起来有点像样板至少，如果您意识到如何通过使用初始值设定项来改进它，请让我知道。提前谢谢你

第一个实现的问题是

let sequence = CustomAnySequence([1, 2, 3])

不满足中的约束

init<S: Sequence>(_ sequence: S) where S.Iterator == Iterator 

并将

sequence.makeIterator（）

传递给

CustomAnyIterator

的init方法

请注意，内部类可以从外部类继承

元素

类型占位符，并且实际上不需要类型别名

final class CustomAnySequence<Element>: Sequence {

    class CustomAnyIterator: IteratorProtocol {
        private let _next: () -> Element?

        init<I: IteratorProtocol>(_ iterator: I) where I.Element == Element {
            var iterator = iterator
            _next = { iterator.next() }
        }

        func next() -> Element? {
            return _next()
        }
    }

    private let _makeIterator: () -> CustomAnyIterator

    init<S: Sequence>(_ sequence: S) where S.Element == Element {
        _makeIterator = { CustomAnyIterator(sequence.makeIterator()) }
    }

    func makeIterator() -> CustomAnyIterator {
        return _makeIterator()
    }
}

final类CustomAnySequence:Sequence{
类CustomAnyIterator:IteratorProtocol{
private let _next:（）->元素？
init（iterator:I），其中I.Element==Element{
变量迭代器=迭代器
_next={iterator.next（）}
}
func next（）->元素{
返回_next（）
}
}
私有let_makeIterator:（）->CustomAnyIterator
init（u序列：S），其中S.Element==Element{
_makeIterator={CustomAnyIterator（sequence.makeIterator（））}
}
func makeIterator（）->CustomAnyIterator{
返回_makeIterator（）
}
}

---

您也可以考虑使用<代码>结构> <代码>而不是<代码>类< /代码> .< /p>非常感谢！花很多时间解决这个问题issue@Yury：不客气我增加了另一个简化。

final class CustomAnySequence<Element>: Sequence {

    class CustomAnyIterator: IteratorProtocol {
        private let _next: () -> Element?

        init<I: IteratorProtocol>(_ iterator: I) where I.Element == Element {
            var iterator = iterator
            _next = { iterator.next() }
        }

        func next() -> Element? {
            return _next()
        }
    }

    private let _makeIterator: () -> CustomAnyIterator

    init<S: Sequence>(_ sequence: S) where S.Element == Element {
        _makeIterator = { CustomAnyIterator(sequence.makeIterator()) }
    }

    func makeIterator() -> CustomAnyIterator {
        return _makeIterator()
    }
}