苹果原生
可变参数压缩函数
Swift 4.1， Xcode 9.4
我最近一直在使用 Apple 的原生zip(_:_:)，我遇到了需要zip两个以上序列的情况。
所以我在 Swift 的 GitHub 页面上查找并找到了zip(_:_:)声明。我获取了这些信息，并能够重载zip(_:_:)接受四个参数，zip(_:_:_:_:).我知道我可以煞费苦心地超载zip以支持我一次选择一个参数的任何数量的参数，但这是不灵活的，耗时的，我觉得可变参数选项会是一个更好的选择。
问题：
如何使本机zip函数接受可以容纳任意数量的序列输入的可变参数。
苹果原生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
警告：此重载仅适用于固定数量的输入，而理想情况下，我正在寻找一个接受不分青红皂白的AnySequence输入的zip函数。
重申一下，我希望创建一个zip(_: AnySequence...)函数，我可以使用该函数通过使用可变参数来压缩任意数量的序列。
提前感谢大家的帮助，我真的很感激！
遗憾的是，这在 Swift 中并不完全可行，因为我们不能为 Variadic 参数使用不同的数组类型。一个可能的解决方法是将所有数组转换为类型[Any]，然后将它们全部压缩在一起形成一个数组数组，而不是使用map，使用强制投射将数组转换为所需的元组。解决方案可能有点脏，但不会太复杂。
extension Sequence {
//easy conversion of any sequence to [Any]
var untyped:[Any] {
return self as! [Any]
}
}
func zip(_ untypedSequences:[Any]...) -> [[Any]] {
let count = untypedSequences.map{$0.count}.min() ?? 0
return (0..<count).map{ index in untypedSequences.map{ $0[index] } }
}
//Test
let test1 = ["a", "b", "c"]
let test2 = [1, 2, 3, 4]
let test3 = [7.2, 12.23, 1.3]
let zippedTests = zip(test1.untyped, test2.untyped, test3.untyped).map {
($0[0] as! String, $0[1] as! Int, $0[2] as! Double)
}
您需要所有函数，但不需要多个 ZipSequence 类型。
@inlinable public func zip<Sequence0: Sequence, Sequence1: Sequence, Sequence2: Sequence>(
_ sequence0: Sequence0, _ sequence1: Sequence1, _ sequence2: Sequence2
) -> AnySequence<(Sequence0.Element, Sequence1.Element, Sequence2.Element)> {
.init(
sequence(
state: (
sequence0.makeIterator(), sequence1.makeIterator(), sequence2.makeIterator()
)
) {
.init(
($0.0.next(), $0.1.next(), $0.2.next())
)
}
)
}
@inlinable public func zip<
Sequence0: Sequence, Sequence1: Sequence, Sequence2: Sequence, Sequence3: Sequence
>(
_ sequence0: Sequence0, _ sequence1: Sequence1, _ sequence2: Sequence2, _ sequence3: Sequence3
) -> AnySequence<(Sequence0.Element, Sequence1.Element, Sequence2.Element, Sequence3.Element)> {
.init(
sequence(
state: (
sequence0.makeIterator(), sequence1.makeIterator(), sequence2.makeIterator(), sequence3.makeIterator()
)
) {
.init(
($0.0.next(), $0.1.next(), $0.2.next(), $0.3.next())
)
}
)
}
public extension Optional {
/// Exchange three optionals for a single optional tuple.
/// - Returns: `nil` if any tuple element is `nil`.
init<Wrapped0, Wrapped1, Wrapped2>(_ optionals: (Wrapped0?, Wrapped1?, Wrapped2?))
where Wrapped == (Wrapped0, Wrapped1, Wrapped2) {
switch optionals {
case let (wrapped0?, wrapped1?, wrapped2?):
self = (wrapped0, wrapped1, wrapped2)
default:
self = nil
}
}
/// Exchange four optionals for a single optional tuple.
/// - Returns: `nil` if any tuple element is `nil`.
init<Wrapped0, Wrapped1, Wrapped2, Wrapped3>(_ optionals: (Wrapped0?, Wrapped1?, Wrapped2?, Wrapped3?))
where Wrapped == (Wrapped0, Wrapped1, Wrapped2, Wrapped3) {
switch optionals {
case let (wrapped0?, wrapped1?, wrapped2?, wrapped3?):
self = (wrapped0, wrapped1, wrapped2, wrapped3)
default:
self = nil
}
}
}