我的问题很简单，如何使这段代码变得懒惰：

/*
input: [
    [1, 2],
    [3, 4],
    [5, 6]
]

output: [
    [1, 3, 5],
    [1, 3, 6],
    [1, 4, 5],
    [1, 4, 6],
    [2, 3, 5],
    [2, 3, 6],
    [2, 4, 5],
    [2, 4, 6],
]
*/

func combinations<T>(options: [[T]]) -> [[T]] {
    guard let head = options.first else {
        return [].map({ [$0] })
    }

    if options.count == 1 {
        return head.map({ [$0] })
    }

    let tailCombinations = combinations(options: Array(options.dropFirst()))

    return head.flatMap({ option in
        return tailCombinations.map({ combination -> [T] in
            return [option] + combination
        })
    })
}

上面的代码可以计算组合，但是可以在内存中创建整个数组数组。我需要让它返回类似的东西LazySequence<Array<T>>，除了Swift类型系统不允许我做一些通用的事情。

有什么想法如何实现这一目标并保持功能风格吗？

附注：我确实想过用生成器解决这个问题并跟踪索引的另一种方法，但是我不想跟踪任何状态，我想要一个纯函数式（如FP中）的解决方案。Haskell默认情况下会这样做，顺便说一句，我正在寻找相同的东西。

编辑： 我已经设法解决了部分问题，类型系统，AnyCollection

func combinations<T>(options: [[T]]) -> LazyCollection<AnyCollection<[T]>> {
    guard let head = options.first else {
        return AnyCollection([].lazy.map({ [$0] })).lazy
    }

    if options.count == 1 {
        return AnyCollection(head.lazy.map({ [$0] })).lazy
    }

    let tailCombinations = combinations(options: Array(options.dropFirst()))

    return AnyCollection(head.lazy.flatMap({ option in
        return tailCombinations.lazy.map({ [option] + $0 })
    })).lazy
}

但是，当我使用该函数时，它将整个集合加载到内存中，即不是惰性的。

编辑2： 做更多的调查，结果问题出在AnyCollection

// stays lazy
let x1 = head.lazy.flatMap({ option in
    return tailCombinations.lazy.map({ [option] + $0 })
})

// forces to load in memory
let x2 = AnyCollection(head.lazy.flatMap({ option in
    return tailCombinations.lazy.map({ [option] + $0 })
}))

尚不确定如何解决此问题。