在swift中连接惰性序列？

我希望能够做一些类似于

[1,2,3]。lazy+[4,5,6]。lazy

而不是

（[1,2,3]+[4,5,6]）。lazy

，因为假设的前一个操作是常量，而后一个是线性的。

使用

序列。joined（）

是一种方法，正如马丁指出的那样。通过使用我制作的垫片，您可以确认它确实是懒惰的：

struct PrintingSequence<S: Sequence>: Sequence {
    let wrapped: S

    init(_ wrapped: S) {
        print("Making a sequence wrapping \(wrapped) of type \(S.self)")
        self.wrapped = wrapped
    }

    func makeIterator() -> PrintingIterator<S.Iterator> {
        return PrintingIterator(wrapped.makeIterator())
    }
}

struct PrintingIterator<I: IteratorProtocol>: IteratorProtocol {
    var wrapped: I


    init(_ wrapped: I) {
        print("\nMaking an iterator wrapping \(wrapped) of type \(I.self)")
        self.wrapped = wrapped
    }

    mutating func next() -> I.Element? {
        let result = self.wrapped.next()
        print("Yielding \(result as Any)")
        return result
    }
}

let joinedSequence = [
    PrintingSequence([1, 2, 3].lazy),
    PrintingSequence([4, 5, 6].lazy)
].joined()

var joinedIterator = joinedSequence.makeIterator()

print("\nAbout to start the loop")
while let i = joinedIterator.next() {
    print("\tloop \(i)")
}

struct PrintingSequence:Sequence{
让我们来看看
初始化（uu包装：S）{
打印（“制作序列包装\（包装）类型\（S.self）”）
自我包装
}
func makeIterator（）->PrintingIterator{
返回PrintingIterator（wrapped.makeIterator（））
}
}
结构打印迭代器：迭代器协议{
问：我
初始化（uu包装：I）{
打印（“\n生成类型为\（I.self）的迭代器包装\（已包装）”）
自我包装
}
变异func next（）->I.元素{
让result=self.wrapped.next（）
打印（“产生\（任何结果）”）
返回结果
}
}
让joinedSequence=[
打印序列（[1,2,3].lazy），
打印顺序（[4,5,6].lazy）
].加入
var joinedIterator=joinedSequence.makeIterator（）
打印（“\n打印以启动循环”）
而let i=joinedIterator.next（）{
打印（“\tloop\（i）”）
}

其中打印：

Making a sequence wrapping LazySequence<Array<Int>>(_base: [1, 2, 3]) of type LazySequence<Array<Int>>
Making a sequence wrapping LazySequence<Array<Int>>(_base: [4, 5, 6]) of type LazySequence<Array<Int>>

About to start the loop

Making an iterator wrapping IndexingIterator<Array<Int>>(_elements: [1, 2, 3], _position: 0) of type IndexingIterator<Array<Int>>
Yielding Optional(1)
    loop 1
Yielding Optional(2)
    loop 2
Yielding Optional(3)
    loop 3
Yielding nil

Making an iterator wrapping IndexingIterator<Array<Int>>(_elements: [4, 5, 6], _position: 0) of type IndexingIterator<Array<Int>>
Yielding Optional(4)
    loop 4
Yielding Optional(5)
    loop 5
Yielding Optional(6)
    loop 6
Yielding nil

制作一个序列包装LazySequence类型的LazySequence（_base:[1,2,3]）
制作一个LazySequence类型的序列包装LazySequence（_base:[4,5,6]）
即将开始循环
生成一个迭代器包装IndexingIterator类型的IndexingIterator（_元素：[1,2,3]，_位置：0）
可选项（1）
回路1
（二）
环路2
（三）
环路3
零收益
制作一个迭代器包装IndexingIterator类型的IndexingIterator（_元素：[4,5,6]，_位置：0）
（四）
环路4
可选项（5）
环路5
可选项（6）
环路6
零收益

[seq1，seq2].joined（）

可能是您正在寻找的，但是一个不太假设的示例会有所帮助。