Variadic Zip功能

Swift 4.1，Xcode 9.4

我最近一直在使用Apple的原生 zip(_:_:) ，我遇到了一个情况，我需要 zip 超过两个序列 .

所以我寻找并找到zip(::) on Swift's GitHub页面的声明 . 我接受了这些信息并且能够重载 zip(_:_:) 以接受四个参数， zip(_:_:_:_:) . 我知道我可以费力地超载 zip 以支持我一次选择一个参数的任何数量，但这是不灵活的，耗时的，我觉得可变选项将是一个更好的选择 .

问题：

How to make the native zip function accept a variadic parameter that can hold any number of sequence inputs.

Apple的Native zip（： :)功能

/// Creates a sequence of pairs built out of two underlying sequences.
///
/// In the `Zip2Sequence` instance returned by this function, the elements of
/// the *i*th pair are the *i*th elements of each underlying sequence. The
/// following example uses the `zip(_:_:)` function to iterate over an array
/// of strings and a countable range at the same time:
///
///     let words = ["one", "two", "three", "four"]
///     let numbers = 1...4
///
///     for (word, number) in zip(words, numbers) {
///         print("\(word): \(number)")
///     }
///     // Prints "one: 1"
///     // Prints "two: 2
///     // Prints "three: 3"
///     // Prints "four: 4"
///
/// If the two sequences passed to `zip(_:_:)` are different lengths, the
/// resulting sequence is the same length as the shorter sequence. In this
/// example, the resulting array is the same length as `words`:
///
///     let naturalNumbers = 1...Int.max
///     let zipped = Array(zip(words, naturalNumbers))
///     // zipped == [("one", 1), ("two", 2), ("three", 3), ("four", 4)]
///
/// - Parameters:
///   - sequence1: The first sequence or collection to zip.
///   - sequence2: The second sequence or collection to zip.
/// - Returns: A sequence of tuple pairs, where the elements of each pair are
///   corresponding elements of `sequence1` and `sequence2`.
@inlinable // FIXME(sil-serialize-all)
public func zip<Sequence1, Sequence2>(
    _ sequence1: Sequence1, _ sequence2: Sequence2
    ) -> Zip2Sequence<Sequence1, Sequence2> {
    return Zip2Sequence(_sequence1: sequence1, _sequence2: sequence2)
}

/// A sequence of pairs built out of two underlying sequences.
///
/// In a `Zip2Sequence` instance, the elements of the *i*th pair are the *i*th
/// elements of each underlying sequence. To create a `Zip2Sequence` instance,
/// use the `zip(_:_:)` function.
///
/// The following example uses the `zip(_:_:)` function to iterate over an
/// array of strings and a countable range at the same time:
///
///     let words = ["one", "two", "three", "four"]
///     let numbers = 1...4
///
///     for (word, number) in zip(words, numbers) {
///         print("\(word): \(number)")
///     }
///     // Prints "one: 1"
///     // Prints "two: 2
///     // Prints "three: 3"
///     // Prints "four: 4"
@_fixed_layout // FIXME(sil-serialize-all)
public struct Zip2Sequence<Sequence1 : Sequence, Sequence2 : Sequence> {
    @usableFromInline // FIXME(sil-serialize-all)
    internal let _sequence1: Sequence1
    @usableFromInline // FIXME(sil-serialize-all)
    internal let _sequence2: Sequence2

    @available(*, deprecated, renamed: "Sequence1.Iterator")
    public typealias Stream1 = Sequence1.Iterator
    @available(*, deprecated, renamed: "Sequence2.Iterator")
    public typealias Stream2 = Sequence2.Iterator

    /// Creates an instance that makes pairs of elements from `sequence1` and
    /// `sequence2`.
    @inlinable // FIXME(sil-serialize-all)
    public // @testable
    init(_sequence1 sequence1: Sequence1, _sequence2 sequence2: Sequence2) {
        (_sequence1, _sequence2) = (sequence1, sequence2)
    }
}

extension Zip2Sequence {
    /// An iterator for `Zip2Sequence`.
    @_fixed_layout // FIXME(sil-serialize-all)
    public struct Iterator {
        @usableFromInline // FIXME(sil-serialize-all)
        internal var _baseStream1: Sequence1.Iterator
        @usableFromInline // FIXME(sil-serialize-all)
        internal var _baseStream2: Sequence2.Iterator
        @usableFromInline // FIXME(sil-serialize-all)
        internal var _reachedEnd: Bool = false

        /// Creates an instance around a pair of underlying iterators.
        @inlinable // FIXME(sil-serialize-all)
        internal init(
            _ iterator1: Sequence1.Iterator,
            _ iterator2: Sequence2.Iterator
            ) {
            (_baseStream1, _baseStream2) = (iterator1, iterator2)
        }
    }
}

extension Zip2Sequence.Iterator: IteratorProtocol {
    /// The type of element returned by `next()`.
    public typealias Element = (Sequence1.Element, Sequence2.Element)

    /// Advances to the next element and returns it, or `nil` if no next element
    /// exists.
    ///
    /// Once `nil` has been returned, all subsequent calls return `nil`.
    @inlinable // FIXME(sil-serialize-all)
    public mutating func next() -> Element? {
        // The next() function needs to track if it has reached the end.  If we
        // didn't, and the first sequence is longer than the second, then when we
        // have already exhausted the second sequence, on every subsequent call to
        // next() we would consume and discard one additional element from the
        // first sequence, even though next() had already returned nil.
        if _reachedEnd {
            return nil
        }

        guard let element1 = _baseStream1.next(),
            let element2 = _baseStream2.next() else {
                _reachedEnd = true
                return nil
        }

        return (element1, element2)
    }
}

extension Zip2Sequence: Sequence {
    public typealias Element = (Sequence1.Element, Sequence2.Element)

    /// Returns an iterator over the elements of this sequence.
    @inlinable // FIXME(sil-serialize-all)
    public func makeIterator() -> Iterator {
        return Iterator(
            _sequence1.makeIterator(),
            _sequence2.makeIterator())
    }
}

// @available(*, deprecated, renamed: "Zip2Sequence.Iterator")
public typealias Zip2Iterator<T, U> = Zip2Sequence<T, U>.Iterator where T: Sequence, U: Sequence

zip（：：： :)函数重载（我的实现）

/// Creates a sequence of pairs built out of four underlying sequences.
///
/// In the `Zip4Sequence` instance returned by this function, the elements of
/// the *i*th pair are the *i*th elements of each underlying sequence. The
/// following example uses the `zip(_:_:_:_:)` function to iterate over an array
/// of strings, an array of bolean values, an array of integer values, and a countable range, at the same time:
///
///     let evens = [false, true, false, true)
///     let squares = [1, 4, 9, 16]
///     let words = ["one", "two", "three", "four"]
///     let numbers = 1...4
///
///     for (word, number, even, square) in zip(words, numbers, evens, squares) {
///         print("\(word): \(number) --> \(number) is \(even ? "even" : "odd") and \(number)² = \(square)")
///     }
///     // Prints "one: 1 --> 1 is odd and 1² = 1"
///     // Prints "two: 2 --> 2 is even and 2² = 4"
///     // Prints "three: 3 --> 3 is odd and 3² = 9"
///     // Prints "four: 4 --> 4 is even and 4² = 16"
///
/// If the four sequences passed to `zip(_:_:_:_:)` are different lengths, the
/// resulting sequence is the same length as the shorter sequence. In this
/// example, the resulting array is the same length as `words`, `evens`, `and `squares`:
///
///     let naturalNumbers = 1...Int.max
///     let zipped = Array(zip(words, naturalNumbers, evens, squares))
///     // zipped == [("one", 1, false, 1), ("two", 2, true, 4), ("three", 3, false, 9), ("four", 4, true, 16)]
///
/// - Parameters:
///   - sequence1: The first sequence or collection to zip.
///   - sequence2: The second sequence or collection to zip.
///   - sequence3: The third sequence or collection to zip.
///   - sequence4: The fourth sequence or collection to zip.
/// - Returns: A sequence of tuple pairs, where the elements of each pair are
///   corresponding elements of `sequence1`, `sequence2`, `sequence3`, and `sequence3`.
public func zip<Sequence1, Sequence2, Sequence3, Sequence4>(
    _ sequence1: Sequence1, _ sequence2: Sequence2, _ sequence3: Sequence3, _ sequence4: Sequence4
    ) -> Zip4Sequence<Sequence1, Sequence2, Sequence3, Sequence4> {
    return Zip4Sequence(_sequence1: sequence1, _sequence2: sequence2, _sequence3: sequence3, _sequence4: sequence4)
}

/// A sequence of pairs built out of four underlying sequences.
///
/// In a `Zip4Sequence` instance, the elements of the *i*th pair are the *i*th
/// elements of each underlying sequence. To create a `Zip4Sequence` instance,
/// use the `zip(_:_:_:_:)` function.
///
/// The following example uses the `zip(_:_:_:_:)` function to iterate over an array
/// of strings, an array of bolean values, an array of integer values, and a countable range, at the same time:
////
///     let evens = [false, true, false, true)
///     let squares = [1, 4, 9, 16]
///     let words = ["one", "two", "three", "four"]
///     let numbers = 1...4
///
///     for (word, number, even, square) in zip(words, numbers, evens, squares) {
///         print("\(word): \(number) --> \(number) is \(even ? "even" : "odd") and \(number)² = \(square)")
///     }
///     // Prints "one: 1 --> 1 is odd and 1² = 1"
///     // Prints "two: 2 --> 2 is even and 2² = 4"
///     // Prints "three: 3 --> 3 is odd and 3² = 9"
///     // Prints "four: 4 --> 4 is even and 4² = 16"
@_fixed_layout // FIXME(sil-serialize-all)
public struct Zip4Sequence<Sequence1 : Sequence, Sequence2 : Sequence, Sequence3 : Sequence, Sequence4 : Sequence> {
    internal let _sequence1: Sequence1
    internal let _sequence2: Sequence2
    internal let _sequence3: Sequence3
    internal let _sequence4: Sequence4

    @available(*, deprecated, renamed: "Sequence1.Iterator")
    public typealias Stream1 = Sequence1.Iterator
    @available(*, deprecated, renamed: "Sequence2.Iterator")
    public typealias Stream2 = Sequence2.Iterator
    @available(*, deprecated, renamed: "Sequence3.Iterator")
    public typealias Stream3 = Sequence3.Iterator
    @available(*, deprecated, renamed: "Sequence4.Iterator")
    public typealias Stream4 = Sequence4.Iterator

    /// Creates an instance that makes pairs of elements from `sequence1` and
    /// `sequence2`.
    public // @testable
    init(_sequence1 sequence1: Sequence1, _sequence2 sequence2: Sequence2, _sequence3 sequence3: Sequence3, _sequence4 sequence4: Sequence4) {
        (_sequence1, _sequence2, _sequence3, _sequence4) = (sequence1, sequence2, sequence3, sequence4)
    }
}

extension Zip4Sequence {
    /// An iterator for `Zip4Sequence`.
    @_fixed_layout // FIXME(sil-serialize-all)
    public struct Iterator {
        internal var _baseStream1: Sequence1.Iterator
        internal var _baseStream2: Sequence2.Iterator
        internal var _baseStream3: Sequence3.Iterator
        internal var _baseStream4: Sequence4.Iterator
        internal var _reachedEnd: Bool = false

        /// Creates an instance around a set of 4 underlying iterators.
        internal init(
            _ iterator1: Sequence1.Iterator,
            _ iterator2: Sequence2.Iterator,
            _ iterator3: Sequence3.Iterator,
            _ iterator4: Sequence4.Iterator
            ) {
            (_baseStream1, _baseStream2, _baseStream3, _baseStream4) = (iterator1, iterator2, iterator3, iterator4)
        }
    }
}

extension Zip4Sequence.Iterator: IteratorProtocol {
    /// The type of element returned by `next()`.
    public typealias Element = (Sequence1.Element, Sequence2.Element, Sequence3.Element, Sequence4.Element)

    /// Advances to the next element and returns it, or `nil` if no next element
    /// exists.
    ///
    /// Once `nil` has been returned, all subsequent calls return `nil`.
    public mutating func next() -> Element? {
        // The next() function needs to track if it has reached the end. If we
        // didn't, and the first sequence is longer than the second, third, and
        // fourth, then when we have already exhausted the second, third, and
        // fourth sequence, on every subsequent call to next() we would consume
        // and discard one additional element from the first sequence, even
        // though next() had already returned nil.
        if _reachedEnd {
            return nil
        }

        guard let element1 = _baseStream1.next(),
            let element2 = _baseStream2.next(),
            let element3 = _baseStream3.next(),
            let element4 = _baseStream4.next()
            else {
                _reachedEnd = true
                return nil
        }

        return (element1, element2, element3, element4)
    }
}

extension Zip4Sequence: Sequence {
    public typealias Element = (Sequence1.Element, Sequence2.Element, Sequence3.Element, Sequence4.Element)

    /// Returns an iterator over the elements of this sequence.
    public func makeIterator() -> Iterator {
        return Iterator(
            _sequence1.makeIterator(),
            _sequence2.makeIterator(),
            _sequence3.makeIterator(),
            _sequence4.makeIterator())
    }
}

@available(*, deprecated, renamed: "Zip4Sequence.Iterator")
public typealias Zip4Iterator<T, U, V, W> = Zip4Sequence<T, U, V, W>.Iterator where T: Sequence, U: Sequence, V: Sequence, W: Sequence

Caveat: 此重载仅适用于固定数量的输入，而我理想地寻找一个接受不加区别的 AnySequence 输入的 zip 函数 .

重申一下，我希望创建一个 zip(_: AnySequence...) 函数，我可以使用它来通过使用可变参数来压缩任意数量的序列 .

提前感谢大家的所有帮助，我真的很感激！