Swift中的变量Zip函数 可变压缩函数 Swift 4.1，Xcode 9.4

最近我一直在使用苹果的原生

zip（::）

，我遇到了一个需要

zip

两个以上序列的情况

因此，我寻找并找到了页面的声明。我获取了这些信息，并且能够重载

zip（\u:\）

以接受四个参数

zip（\u:\）

。我知道我可以费力地重载

zip

，以支持我一次选择一个参数的任何数量，但这是不灵活的、耗时的，而且我觉得可变选项将是更好的选择

问题: 如何使本机

zip

函数接受可容纳任意数量序列输入的可变参数。

---

苹果的原生

zip（::）

功能

///创建由两个底层序列构成的对序列。
///
///在该函数返回的'Zip2Sequence'实例中
///*i*th对是每个底层序列的*i*th元素。这个
///下面的示例使用'zip（::）`函数对数组进行迭代
///同时包含字符串和可数范围：
///
///让单词=[“一”、“二”、“三”、“四”]
///让数字=1…4
///
///用于zip中的（单词、数字）（单词、数字）{
///打印（“\（单词）：\（数字）”）
///     }
/////打印“一：1”
/////打印“2:2”
/////打印“三：3”
/////打印“四：4”
///
///如果传递给'zip（:：）'的两个序列长度不同，则
///结果序列的长度与较短序列的长度相同
///例如，结果数组的长度与“words”相同：
///
///设自然数=1…Int.max
///设zipped=Array（zip（字、自然数））
/////压缩==[（“一”，1），（“二”，2），（“三”，3），（“四”，4）]
///
///-参数：
///-sequence1：要压缩的第一个序列或集合。
///-sequence2：要压缩的第二个序列或集合。
///-返回：元组对的序列，其中每个元组对的元素是
///“sequence1”和“sequence2”的对应元素。
@可插入//修复程序（sil序列化全部）
公共职能邮政编码(
_sequence1:sequence1，uSequence2:sequence2
)->Zip2序列{
返回ZIP2序列（_sequence1:sequence1，_sequence2:sequence2）
}
///由两个基本序列构成的成对序列。
///
///在'Zip2Sequence'实例中，*i*th对的元素是*i*th
///每个基础序列的元素。要创建'Zip2Sequence'实例，
///使用'zip（:：）'函数。
///
///下面的示例使用'zip（::）`函数在
///同时包含字符串数组和可数范围：
///
///让单词=[“一”、“二”、“三”、“四”]
///让数字=1…4
///
///用于zip中的（单词、数字）（单词、数字）{
///打印（“\（单词）：\（数字）”）
///     }
/////打印“一：1”
/////打印“2:2”
/////打印“三：3”
/////打印“四：4”
@_固定布局//FIXME（sil序列化所有）
公共结构ZIP2序列{
@usableFromInline//FIXME（sil序列化全部）
内部let_sequence1:sequence1
@usableFromInline//FIXME（sil序列化全部）
内部let_sequence2:sequence2
@可用（*，不推荐，重命名为：“Sequence1.Iterator”）
公共类型别名Stream1=Sequence1.迭代器
@可用（*，不推荐，重命名为：“Sequence2.Iterator”）
公共类型别名Stream2=Sequence2.迭代器
///创建一个实例，使“sequence1”和
///`sequence2`。
@可插入//修复程序（sil序列化全部）
public/@可测试
初始化（_sequence1sequence1:sequence1，_sequence2sequence2:sequence2）{
（_sequence1，_sequence2）=（sequence1，sequence2）
}
}
扩展ZIP2序列{
///“Zip2Sequence”的迭代器。
@_固定布局//FIXME（sil序列化所有）
公共结构迭代器{
@usableFromInline//FIXME（sil序列化全部）
内部变量baseStream1:Sequence1.迭代器
@usableFromInline//FIXME（sil序列化全部）
内部变量baseStream2:Sequence2.迭代器
@usableFromInline//FIXME（sil序列化全部）
内部变量到达端：Bool=false
///围绕一对基础迭代器创建一个实例。
@可插入//修复程序（sil序列化全部）
内部初始化(
_迭代器1:Sequence1.迭代器，
_迭代器2:Sequence2.迭代器
) {
（_baseStream1，_baseStream2）=（迭代器1，迭代器2）
}
}
}
扩展Zip2Sequence.迭代器：迭代器协议{
///“next（）”返回的元素类型。
公共类型别名元素=（Sequence1.Element，Sequence2.Element）
///前进到下一个元素并返回它，如果没有下一个元素，则返回'nil'
///存在。
///
///一旦返回'nil'，所有后续调用都将返回'nil'。
@可插入//修复程序（sil序列化全部）
公共变异func next（）->元素{
//next（）函数需要跟踪它是否已到达末尾
//没有，第一个序列比第二个序列长，然后当我们
//在以后每次调用
//next（）我们将从
//第一个序列，即使next（）已返回nil。
如果你到达终点{
归零
}
guard let element1=_baseStream1.next（），
让element2=_baseStream2.next（）else{
_reachedEnd=true
归零
}
返回（元素1、元素2）
}
}
扩展Zip2Sequence:序列{
公共类型别名元素=（Sequence1.Element，Sequence2.Element）
///返回此序列元素的迭代器。
@可插入//修复程序（sil序列化全部）
酒吧