Merge pull request scala#7745 from NthPortal/topic/ll-sliding/PR

[bug#11399] Fix LazyList#sliding

Author: Ichoran

src/library/scala/collection/immutable/LazyList.scala

@@ -572,8 +572,11 @@ final class LazyList[+A] private(private[this] var lazyState: () => LazyList.Sta
     if (knownIsEmpty) LazyList.empty
     else super.intersect(that)
 
-  // TODO: override to detect cycles
-  override def distinctBy[B](f: A => B): LazyList[A] = super.distinctBy(f)
+  @tailrec
+  private def lengthLteq(len: Int): Boolean =
+    if (len < 0) false
+    else if (isEmpty) true
+    else tail.lengthLteq(len - 1)
 
   override def grouped(size: Int): Iterator[LazyList[A]] = {
     require(size > 0, "size must be positive, but was " + size)
@@ -587,11 +590,11 @@ final class LazyList[+A] private(private[this] var lazyState: () => LazyList.Sta
 
   @inline private def lazySlidingImpl(size: Int, step: Int): Iterator[LazyList[A]] =
     if (knownIsEmpty) Iterator.empty
-    else Iterator.empty ++ slidingImpl(size, step) // concat with empty iterator so that `slidingImpl` is lazy
+    else Iterator.empty ++ slidingImpl(size, step, size - step max 0) // concat with empty iterator so that `slidingImpl` is lazy
 
-  private def slidingImpl(size: Int, step: Int): Iterator[LazyList[A]] =
-    if (isEmpty) Iterator.empty
-    else Iterator.single(take(size)) ++ drop(step).slidingImpl(size, step)
+  private def slidingImpl(size: Int, step: Int, minLen: Int): Iterator[LazyList[A]] =
+    if (lengthLteq(minLen)) Iterator.empty
+    else Iterator.single(take(size)) ++ drop(step).slidingImpl(size, step, minLen)
 
   override def padTo[B >: A](len: Int, elem: B): LazyList[B] = {
     if (len <= 0) this

test/junit/scala/collection/immutable/LazyListLazinessTest.scala

@@ -460,22 +460,26 @@ class LazyListLazinessTest {
     assertLazyAllSkipping(_ forall { _ < 2 }, 3)
   }
 
-  private def genericSliding_properlyLazy(op: LazyListOp[Iterator[LazyList[Int]]]): Unit = {
-    assertLazyAll(op)
-    assertLazyAllSkipping(op andThen { _.hasNext }, 1)
-    assertLazyAllSkipping(op andThen { _.next().force }, 3)
-    assertKnownEmptyYields(op)(_ eq Iterator.empty)
+  private def genericSliding_properlyLazy(op: (LazyList[Int], Int) => Iterator[LazyList[Int]],
+                                          skipExtra: Int = 0): Unit = {
+    val op3 = lazyListOp(op(_, 3))
+    assertLazyAll(op3)
+    assertLazyAllSkipping(op3 andThen { _.hasNext }, 1 + skipExtra)
+    assertLazyAllSkipping(op3 andThen { _.next().force }, 3 + skipExtra)
+    assertKnownEmptyYields(op3)(_ eq Iterator.empty)
   }
 
   @Test
   def grouped_properlyLazy(): Unit = {
-    genericSliding_properlyLazy(_ grouped 3)
+    genericSliding_properlyLazy(_ grouped _)
   }
 
   @Test
   def sliding_properlyLazy(): Unit = {
-    genericSliding_properlyLazy(_ sliding 3)
-    genericSliding_properlyLazy(_.sliding(3, 2))
+    genericSliding_properlyLazy(_ sliding _, 2)
+    genericSliding_properlyLazy(_.sliding(_, 2), 1)
+    genericSliding_properlyLazy(_.sliding(_, 3))
+    genericSliding_properlyLazy(_.sliding(_, 4))
   }
 
   @Test