коллекции скольжения() противоречива, если размер окна больше, чем шаг

Question

Это Scala коллекция API, sliding() в Scala:

/** Groups elements in fixed size blocks by passing a "sliding window" 
    * over them (as opposed to partitioning them, as is done in grouped.) 
    * @see [[scala.collection.Iterator]], method `sliding` 
    * 
    * @param size the number of elements per group 
    * @param step the distance between the first elements of successive 
    *   groups 
    * @return An iterator producing ${coll}s of size `size`, except the 
    *   last and the only element will be truncated if there are 
    *   fewer elements than size. 
    */ 
    def sliding(size: Int, step: Int): Iterator[Repr] = 

Простой способ понять это, что скольжение просто (0 until this.length by step).map(i => slice(i, i + size)). Но эта интерпретация не работает, когда size > step:

object SlidingTest extends App { 
    val n = 10 

    val r1 = 0 until n 

    val r2 = new Range(start = 0, end = n, step = 1) { 
    override def sliding(size: Int, step: Int) = 
    (indices by step).iterator.map(i => slice(i, i + size)) 
    } 

    for { 
    i <- 1 to 2*n 
    j <- 1 to 2*n 
    s1 = r1.sliding(i, j).toList.map(_.toList) 
    s2 = r2.sliding(i, j).toList.map(_.toList) 
    if s1 != s2 
    } println(s"Sliding fail for size=$i and step=$j: [s1=$s1; s2=$s2]") 
} 

В частности рассмотреть r1 = 0 until 10. Согласно документации, r1.sliding(size = 2, step = 1) должен быть таким:

List(List(0, 1), List(1, 2), List(2, 3), List(3, 4), List(4, 5), List(5, 6), List(6, 7), List(7, 8), List(8, 9), List(9)) 

Но на самом деле это:

List(List(0, 1), List(1, 2), List(2, 3), List(3, 4), List(4, 5), List(5, 6), List(6, 7), List(7, 8), List(8, 9)) 

(т.е. последний усеченный фрагмент отсутствует).

Другой фрагмент скопирован из Scaladoc:

/** Returns an iterator which presents a "sliding window" view of 
    * another iterator. The first argument is the window size, and 
    * the second is how far to advance the window on each iteration; 
    * defaults to `1`. Example usages: 
    * {{{ 
    * // Returns List(List(1, 2, 3), List(2, 3, 4), List(3, 4, 5)) 
    * (1 to 5).iterator.sliding(3).toList 
    * // Returns List(List(1, 2, 3, 4), List(4, 5)) 
    * (1 to 5).iterator.sliding(4, 3).toList 
    * // Returns List(List(1, 2, 3, 4)) 
    * (1 to 5).iterator.sliding(4, 3).withPartial(false).toList 
    * // Returns List(List(1, 2, 3, 4), List(4, 5, 20, 25)) 
    * // Illustrating that withPadding's argument is by-name. 
    * val it2 = Iterator.iterate(20)(_ + 5) 
    * (1 to 5).iterator.sliding(4, 3).withPadding(it2.next).toList 
    * }}} 
    * 
    * @note Reuse: $consumesAndProducesIterator 
    */ 
    def sliding[B >: A](size: Int, step: Int = 1): GroupedIterator[B] = 
    new GroupedIterator[B](self, size, step) 

Что я делаю неправильно?

Answer 1

На основании ответа @ SOM-snytt, я нашел способ выразить sliding с точки зрения slice следующим образом:

override def sliding(window: Int, step: Int) = { 
    require(window > 0 && step > 0, s"window=$window and step=$step, but both must be positive") 
    val lag = (window - step) max 0 
    Iterator.range(start = 0, end = length - lag, step = step).map(i => slice(i, i + window)) 
} 

Answer 2

Он группирует элементы и останавливается, когда все сгруппировано.

Это не группа на каждом возможном этапе.

scala> (1 to 100).sliding(size=100,step=1).toList.size 
res0: Int = 1 

scala> (1 to 100).sliding(size=99,step=1).toList.size 
res1: Int = 2 

В вашем примере, вы ожидаете, что создать дополнительную группу с 9, хотя коллекция уже исчерпывающе сгруппированных.

Вы также показать пример, в котором элементы образуют частичную группу:

scala> (1 to 5).sliding(size=4,step=3).toList 
res4: List[scala.collection.immutable.IndexedSeq[Int]] = List(Vector(1, 2, 3, 4), Vector(4, 5)) 

Дополнительная группа необходима потому, что 5 остается разгруппированы.

Редактировать: возможное перефразирование из Scaladoc:

Итератор производит $ {Coll} с размером size, за исключением последнего элемента (который может быть единственным элементом) будет обрезан, если есть меньше , чем size элементов, которые необходимо сгруппировать.