scala - 从项的迭代器创建子序列的迭代器

Question

如果我有一个Seq，那么很容易生成不超过给定长度限制的所有子序列，如下所示:

def subseqs[A](n: Int)(s: Seq[A]) = {
  (1 to n).flatMap(s.sliding)
}                                            

subseqs(3)(List(1, 2, 3, 4)) foreach println    //> List(1)
                                                //| List(2)
                                                //| List(3)
                                                //| List(4)
                                                //| List(1, 2)
                                                //| List(2, 3)
                                                //| List(3, 4)
                                                //| List(1, 2, 3)
                                                //| List(2, 3, 4)

但是，是否有一种惯用的(并且相当有效)的方法来使用迭代器作为输入来执行相同的操作，生成迭代器(或者可能是 Stream)作为输出？

更新:我有一个 working implementation它实现了 Iterator，并在一次传递中执行此操作，因此需要很少的内存，但相对较长并且使用可变变量(var 和 ListBuffer) - 如果这会有所帮助。我希望有一种使用高阶函数的更优雅的方式...

上面的方法(使用 sliding())将不起作用，因为迭代器在第一次通过时就已耗尽，并且无法重复使用。

结合使用 sliding() 和 inits() 会更好，但会错过预期子序列的尾端:

def subseqsi[A](n: Int)(i: Iterator[A]) = {
  //(1 to n).flatMap(i.sliding) 
  // no - this exhausts the iterator

  i.sliding(n).flatMap { _.inits.filterNot(_.isEmpty) } 
  //nearly, this misses off subsequences towards the end
} 
                                              //> List(1, 2, 3)
                                              //| List(1, 2)
                                              //| List(1)
                                              //| List(2, 3, 4)
                                              //| List(2, 3)
                                              //| List(2)

我的输入数据是一个未知(可能非常大)大小的迭代器。输出子序列的顺序无关紧要。

Answer 1

只需使用一个流:

def subseqs[A](n: Int)(iter: Iterator[A]) = {
  val i = iter.toStream
  1 to n flatMap i.sliding
}

Stream 和 Iterator 一样惰性，但它存储所有已计算的值。