Sequence是整个Swift标准库中整个集合类型体系的起点，它抽象了一个集合最朴素的形式。有多朴素呢？用文字描述出来就是：仅表示一系列类型相同的元素，而不对这一系列元素的性质有任何额外的约定。例如：是否可以多次遍历，是否可以逆序排列，甚至是否包含有限个元素等都没有约定。它唯一约定了的动作，就是从序列当前位置读取下一个元素。
从定义理解Sequence
了解了Sequence的想法之后，我们直接来看Swift中对应的实现。这部分代码在stdlib/public/core/Sequence.swift里：
public protocol Sequence {
associatedtype Element
func makeIterator() -> Iterator
}
实际上，在Sequence.swift开始，有一大段官方的注释解释了这个protocol设计的想法，看过这个系列的内容之后，推荐大家去读一下它们。不过现在，还是顺着我们的思路继续。可以看到，Sequence约定的内容非常简单：
-
Element表示序列中元素的类型； -
makeIterator则返回一个Iterator对象，所谓的Iterator，可以把它看成一个了解序列内部构造的黑盒子，可以帮助我们用一致的接口获取任何序列的“下一个”元素。它的定义在这里：
public protocol IteratorProtocol {
associatedtype Element
mutating func next() -> Element?
}
其中：
-
Element表示这个接口返回的元素类型； -
next()方法，就是刚才说到的访问序列下一个元素的接口。由于不一定可以从序列中获取到下一个元素，因此，next的返回值是Element?。至于为什么next要约束成一个mutating方法，我们稍后用两个例子来解释。
看到这你可能会想了，Sequence.makeIterator返回的对象中Element的类型，和IteratorProtocol中的Element应该是一样的啊。事实上，的确如此，在Sequence的实现里，Iterator的定义是这样的：
public protocol Sequence {
associatedtype Iterator : IteratorProtocol
where Iterator.Element == Element
}
最后，把Sequence完整的定义列出来：
public protocol IteratorProtocol {
associatedtype Element
mutating func next() -> Element?
}
public protocol Sequence {
associatedtype Iterator : IteratorProtocol
where Iterator.Element == Element
func makeIterator() -> Iterator
}
这就是Swift中，最朴实的一类集合的约定。对于一个遵从了Sequence的类型，就像我们在一开始说的一样，我们不知道它包含的元素个数、不知道它是否可以反复遍历、不知道它是否可以逆序。我们能做的，就是通过它的Iterator获取集合中的下一个元素，而这也是我们唯一可以做的事情。
尽管Swift还通过extension给Sequence添加了很多方法，但它们并不是Sequence约束的一部分。也就是说，当自定义一个遵从了Sequence的类型时，不用重新实现它们。
三种不同性质的Sequence
接下来，为了更具象的了解Sequence类型的“质朴”，我们来看三个具体的例子。第一个例子，是我们最容易理解的数组。把它“降维”理解成一个序列完全没问题：
let array = [1, 2, 3, 4, 5, 6]
对于array表示的这个数字序列来说，如果不把它当数组看，我们访问它的元素就只能依靠不断调用Array.Iterator的next方法：
var ia = arr.makeIterator()
while let item = ia.next() {
print(item)
}
显然，这种从数组“降维”而来的序列有有限个元素并且支持重复遍历。
第二个例子，Sequence表示的序列也可以是包含无限个元素的（一直到序列中元素值溢出），例如一个Fibonacci数列。为了表示这样的类型，我们先定义对应的Iterator：
struct FibonacciIterator: IteratorProtocol {
// typealias int = Element
var state = (curr: 0, next: 1)
mutating func next() -> Int? {
let curr = state.curr
state = (curr: state.next, next: state.curr + state.next)
return curr
}
}
然后再来定义数列自身：
struct Fibonacci: Sequence {
// typealias int = Element
// typealias Iterator = FibonacciIterator
func makeIterator() -> FibonacciIterator {
return FibonacciIterator()
}
}
在注释里，我分别列出了FibonacciIterator和Fibonacci中对应的associatedtype类型，为的是帮助我们理解它的定义。实际上这是不必要的，Swift可以根据makeIterator以及next的返回值推导出它们。
现在，思考一个问题，该如何表达一个Fibonacci数列呢？我给你下面两个答案，你选哪个：
/// A
var fibA = FibonacciIterator()
/// B
var fibB = Fibonacci()
是A还是B呢？其实答案是无论哪个都可以。对于fibA来说，我们的侧重点是事实，毕竟只要像下面这样就可以得到数列了：
fibA.next()
fibA.next()
fibA.next()
/// ...
而对于fibB来说，我们的侧重点是形式，Fibonacci数列是一个Sequence。按照约定，为了访问Sequence的每一个成员，我们要获取它的专属Iterator，然后通过next方法完成：
var iterB = fibB.makeIterator()
iterB.next()
iterB.next()
iterB.next()
/// ...
说到这，我们再来回答一个问题，既然FibonacciIterator自身就可以表达一个序列，为什么还要单独定义Fibonacci呢？或者说，为什么要分开Iterator和Sequence呢？
这个问题的答案和两个因素相关，它们是：Sequence的值和Iterator的状态。通常，Iterator为了可以持续遍历序列，它在内部都要保存一个状态。当这个状态和Sequence要表达的值一致的时候，Iterator和Sequence的界限就会变得模糊，甚至可以说Iterator自身就表示了这个序列。为了看到这个效果，我们可以直接让FibonacciIterator遵从Sequence：
struct FibonacciIterator: IteratorProtocol, Sequence {
/// The same as before
/// ...
}
这样，FibonacciIterator就“名正言顺”的成为了一个序列，我们也不用为它专门编写makeIterator方法。这是因为，在Sequence代码里，Swift官方已经为这种情况提供了一个默认实现：
/// A default makeIterator() function for `IteratorProtocol` instances that
/// are declared to conform to `Sequence`
extension Sequence where Self.Iterator == Self {
/// Returns an iterator over the elements of this sequence.
@inlinable
public __consuming func makeIterator() -> Self {
return self
}
}
但绝大多数时候，Iterator保持的状态，和Sequence的值，并不是一致的。这时，就必须通过独立的类型来表达Iterator和Sequence了，而这就是我们要演示的第三类Sequence。这次，我们定义一个由用户输入的每一行内容形成的序列。
先来定义Iterator：
struct InputStreamIterator: IteratorProtocol {
var currLine = 0
mutating func next() -> String? {
guard let input = readLine() else { return nil }
currLine += 1
print("(\(currLine)) \(input)")
return input
}
}
这次，Iterator中用于维系遍历的状态，是currLine，表示这是当前第几行输入，然后在控制台打印类似(1) Hello world这种形式的字符串，并返回当前用户输入的内容。
接下来，定义表示这个序列的类型：
struct InputStream: Sequence {
func makeIterator() -> InputStreamIterator {
return InputStreamIterator()
}
}
最后，用下面的代码来测试：
let stdin = InputStream()
var stdinIter = stdin.makeIterator()
while true {
guard let _ = stdinIter.next() else { break }
}
把这些代码保存在demo.swift里，并执行swiftc demo.swift -o demo。编译完成后，执行demo，随着在控制台中一行行输入内容，就可以看到类似下面这样的结果了：
ha
(1) ha
haha
(2) haha
hahaha
(3) hahaha
hahahaha
(4) hahahaha
通过这三个例子，我们应该可以彻底明白Sequence要表达的概念了。对于一系列类型相同的序列来说：
- 它的值可以是预分配的，例如数组中的元素。也可以是
lazy的，例如Fibonacci中的访问时现算，或者InputStream中用户的当前输入； - 它的元素个数可以是有限的（
array），也可以是无限的（Fibonacci / InputStream）； - 它可以被反复遍历（
array / Fibonacci），或者只能遍历一次（InputStream）；