swift - 解释 Swift 迭代器

Question

很少有关于如何在 Swift 中制作生成器(或 迭代器，因为它们显然在 Swift 中被称为)的最新指南，特别是如果您是该语言的新手。为什么有这么多生成器类型，例如 AnyIterator 和 UnfoldSequence？为什么下面的代码不能工作？

func chain(_ segments: Any...) -> AnyIterator<Int>{
    return AnyIterator<Int> {
        for segment in segments {
            switch segment {
            case let segment as Int:
                return segment
            case let segment as [Int]:
                for i in segment {
                    return i
                }
            default:
                return nil
            }
        }
        return nil
    }
}

let G = chain(array1, 42, array2)
while let g = G.next() {
    print(g)
}

按照我的理解，AnyIterator 应该采用 {} 中的闭包并将其转换为 .next() 返回的生成器中的方法，但它似乎不起作用。或者我应该像 this question 那样使用 UnfoldSequence反而。我很困惑。

Answer 1

是的，AnyIterator 的next() 方法调用给定的闭包。在您的代码中，该闭包在每次调用时返回相同的第一个元素，因为它不记得已经返回了哪些元素。

如果 Swift 像 Python 或 C# 一样有一个 yield 语句，那么事情会更简单:你可以 yield segment 或 yield i 并完成.

但是——不幸的是？ – Swift 没有yield 语句，这意味着闭包必须显式管理某些状态才能恢复迭代每次调用都包含下一个元素。

一种可能性是维护两个索引，一个用于当前段和一个用于当前元素一个段，如果它是一个数组:

func chain(_ segments: Any...) -> AnyIterator<Int> {
    var currentSegment = 0 // index of current segment
    var currentElement = 0 // index of current element within current segment
    return AnyIterator<Int> {
        while currentSegment < segments.count {
            let next = segments[currentSegment]
            switch next {
            case let value as Int:
                currentSegment += 1
                return value
            case let segment as [Int]:
                if currentElement < segment.count {
                    let val = segment[currentElement]
                    currentElement += 1
                    return val
                }
                currentSegment += 1
                currentElement = 0
            default:
                return nil
            }
        }
        return nil
    }
}

这可以推广到任意嵌套的数组:

func chain(_ segments: Any...) -> AnyIterator<Int> {
    var stack: [(Any, Int)] = [(segments, 0)]
    return AnyIterator<Int> {
        while let (next, idx) = stack.popLast() {
            switch next {
            case let value as Int:
                return value
            case let segments as [Any]:
                if idx < segments.count {
                    stack.append((segments, idx + 1))
                    stack.append((segments[idx], 0))
                }
            default:
                return nil
            }
        }
        return nil
    }
}

待处理的数组与他们目前的指数。数组本身没有被修改，这样副本就便宜了。

例子:

let G = chain([1, 2, [3]], 4, [5, 6, [], 7])
while let g = G.next() {
    print(g)
}
// 1 2 3 4 5 6 7

另见 Implementing recursive generator for simple tree structure in Swift更多递归枚举树状结构的方法。