时间戳

首页 > 解决方案 > 当我尝试提供自己的 AnySequence 实现时，Swift 无法推断泛型类型

swift - 当我尝试提供自己的 AnySequence 实现时，Swift 无法推断泛型类型

问题描述

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

所以，我在玩 Swift 的类型擦除技术，试图熟悉它的想法。基本上，在我接触到Sequence协议之前，它已经很容易理解了。众所周知，它有一个关联类型 - Iterator，它符合IteratorProtocol。也就是说，我一直在尝试在自己的实现中实现类似的行为。这就是我所做的：

final class CustomAnySequence<Element>: Sequence {

    class CustomAnyIterator<Element>: 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()
        }
    }

    typealias Iterator = CustomAnyIterator<Element>
    typealias Element = Iterator.Element


    private let _makeIterator: () -> Iterator


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

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

}

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

因此，最后一行给出了以下错误：Generic parameter 'Element' could not be inferred。

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

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

它并没有让它变得更好。下一个 Xcode 投诉是：Generic parameter 'S' could not be inferred。

那么是我的错，还是 Swift 的类型推断开销太大？

实际上，我遇到了另一种可能的实现——它使用私有子类包装。我真的不喜欢它（这就是我尝试自己做的原因），因为在超类的实现中有“致命错误必须被子类化”的方法，它们对干净的代码没有贡献。另外，我不确定如何通过 CustomAnySequence 的初始化程序来实现此功能（我只是通过制作静态方法才发现它可能）。尽管如此，这就是代码：

class CustomAnySequence<Element>: Sequence {
    class Iterator: IteratorProtocol {
        func next() -> Element? {
            fatalError("Must be overriden")
        }
    }

    func makeIterator() -> Iterator {
        fatalError("Must be overriden")
    }
}

private final class CustomAnySequenceImplementation<S: Sequence>: CustomAnySequence<S.Element> {
    final class IteratorImplementation: Iterator {
        var wrapped: S.Iterator

        init(_ wrapped: S.Iterator) {
            self.wrapped = wrapped
        }

        override func next() -> S.Element? {
            return wrapped.next()
        }
    }

    var sequence: S

    init(_ sequence: S) {
        self.sequence = sequence
    }

    override func makeIterator() -> IteratorImplementation {
        return IteratorImplementation(sequence.makeIterator())
    }
}


extension CustomAnySequence {
    static func make<S: Sequence>(_ sequence: S) -> CustomAnySequence<Element> where S.Element == Element {
        return CustomAnySequenceImplementation<S>(sequence)
    }
}

func printInts(_ sequence: CustomAnySequence<Int>) {
    for element in sequence {
        print(element)
    }
}


printInts(CustomAnySequence.make([1, 2, 3]))
printInts(CustomAnySequence.make(Set([4, 5, 6])))

它确实有效，但它看起来有点像样板。至少，如果您知道如何通过使用初始化程序来改进它，请告诉我。先感谢您！

标签： swiftgenericsswift-protocolstype-erasureassociated-types

解决方案

第一个实现的问题是

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

不满足约束

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

[1, 2, 3]是一个序列，但它的迭代器类型不是你的CustomAnyIterator. 您真正想要的是传递具有相同元素类型的序列，而不是相同的迭代器类型：

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

并传递sequence.makeIterator()给 init 的方法CustomAnyIterator。

还要注意内部类可以从外部类继承Element类型占位符，并且类型别名并不是真正需要的。

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()
    }
}

您也可以考虑使用 astruct而不是 a class。

推荐阅读