原文作者:Erica Sadun
原文链接:http://ericasadun.com
时间:2016年7月19日
译者:与狼同行

最近几天我从Swift-Ev看到一个十分有趣的请求。

某位来自Swift-Ev社区成员:当我敲代码的时候,我很多次都会遇到这样一个情型,当使用‘repeat...while’循环时,循环条件依赖于那些在循环体中被声明变量。

repeat {
    let success = doSomething()
} while !success

这个请求吸引我的地方是它既需要范围内可见的状态(success)而且还需要这个控制语句的状态(success)没有在外部范围内被声明。

不用担心,其实这个机制已经在Swift中存在,来看看Swift里新的sequence函数。Swift提供了2个种类,两个方式都提供基于循环域来建立状态。

1.public func sequence<T>(first: T, next: (T) -> T?) -> UnfoldSequence<T, (T?, Bool)>

译者解读:
该函数功能为返回从以first”作为开始元素到不断被"next"先前元素所返回的结果的一个队列。
例如:
// 我们可以来走一遍树的元素,从一个节点到它的根元素
 for node in sequence(first: leaf, next: { $0.parent }) {
       node是叶子节点, 然后是它的父节点, 再然后是它的父节点的父节点, etc.
}
public func sequence<T>(first: T, next: (T) -> T?) -> UnfoldFirstSequence<T> {
  // 源码中其实调用了第二种函数,可以看出队列第一个first的元组是true,则直接输出第一个first元素,然后接下来队列中的元素都执行next后返回结果,直到最后结果为nil
  return sequence(state: (first, true), next: { (state: inout (T?, Bool)) -> T? in
    switch state {
    case (let value, true):
      state.1 = false
      return value
    case (let value?, _):
      let nextValue = next(value)
      state.0 = nextValue
      return nextValue
    case (nil, _):
      return nil
    }
  })
}

2.public func sequence<T, State>(state: State, next: (inout State) -> T?) -> UnfoldSequence<T, State>

译者解读:
源码为:
public func sequence<T, State>(state: State, next: (inout State) -> T?)
  -> UnfoldSequence<T, State> {
  return UnfoldSequence(_state: state, _next: next)
//这里调用了另外一个结构体UnfoldSequence,名为展开队列
}
public struct UnfoldSequence<Element, State> : Sequence, IteratorProtocol {
  public mutating func next() -> Element? {
    guard !_done else { return nil }
    if let elt = _next(&_state) {
//这句可以看出为什么sequence函数的next的返回类型都是可选类型,
//当执行next循环语句返回nil,队列剩余部分则不执行next函数,全部返回nil
        return elt
    } else {
        _done = true
        return nil
    }
  }
  internal init(_state: State, _next: (inout State) -> Element?) {
    self._state = _state
    self._next = _next
  }
  internal var _state: State
  internal let _next: (inout State) -> Element?
  internal var _done = false
}

两者之间的不同之处在于,第一个更简单的函数产生一个和它状态相同类型的sequence序列。而第二个函数则将状态类型和输出类型区分了出来,因此你可以生成整数,并且同时对字符串做出处理。

现在你来仔细想一想,是不是发现repeat-while真是就像是一个另外一种形式的sequence序列。下面我们来举一个简单的例子。

var i = 0
repeat {
    print(i) // some loop body
    i = i + 5
} while i <= 100

现在你看了上述的内容,你可以进行重写,来试着把i状态变量纳入控制结构,就像这样:

for i in sequence(first: 0, next: { $0 + 5 }) {
    print (i) // some loop body
    if i >= 100 { break } 
}

或者你可以更大胆一些,试着把所有的行为和状态写入next闭包中,就像这样:

for _ in sequence(first: 0, next: {
    print($0) // some loop body
    let value = $0 + 5
    return value <= 100 ? value : nil
}) {}

这里有3件比较重要的事关于这项第三种写法:
1.这个for循环不需要变量。它只是被用于去执行这个序列。
2.这个循环体是空的,它仅仅被用于完成这个语法。当然你也可以去执行数组(也算一个序列),但那样将会需要申请内存,那个做法是十分浪费的。
3.这个序列当返回nil时会终止。这就意味着这个闭包的返回类型是T？,而T则是第一个参数的类型。在这个例子中return的值只可以返回数字类型,因为这个值并没有有意义的用途,它只是被用于检查false/nil。

如果你想结合Bool条件,有一种快速的方法,可以把Bool类型转化为一个可选。虽然这样做有些过了,但它的确能完成任务。

extension Bool { var opt: Bool? { return self ? self : nil } }

或者,你也可以写一个函数来处理Boolean作为控制语句,这样你就不需要转换Boolean作为可选。

这个perform函数是用于创造一个状态化的repeat-while循环,它使用一个Boolean作为控制,封装了sequence函数的使用,并且允许这个循环体是一个尾随闭包。

func perform<T>(
    with state: T,
    while test: (T) -> Bool,
    repeat body: (inout T) -> Void) -> T {
    var updatedState: T = state
    let boolSequence = sequence(state: state, next: {
        (state: inout T) -> Bool? in
        body(&state)
        updatedState = state
        return test(updatedState) ? true : nil
    })
    for _ in boolSequence {}
    return updatedState
}

// 下面的示例将这些单词连接到一个空格分隔的字符串中。
let joinedWords = perform(
    with: ["Lorem", "ipsum", "dolor", "sit", "amet", "consectetur", "adipiscing", "elit"],
    while: { $0.count > 1 })
{
    (state: inout [String]) in
    guard state.count >= 2 else { return }
    let (last, butLast) = (state.removeLast(), state.removeLast())
    let joinedLast = butLast + " " + last
    state.append(joinedLast)
}.first!

debugPrint(joinedWords)
输出结果为:"Lorem ipsum dolor sit amet consectetur adipiscing elit"

这里最关键的地方是初始的单词数组(指["Lorem", "ipsum"...])并没有被存储在循环外部的任何地方,但是可以在循环体内操作。
我相信这个特性正符合社区成员所说的"当使用‘repeat...while’循环时,循环条件依赖于那些在循环体中被声明变量"这句话。