Revert LazyList back to Stream for Shrink

Author: ashawley

src/main/scala/org/scalacheck/Prop.scala

@@ -15,7 +15,6 @@ import language.reflectiveCalls
 import rng.Seed
 import util.{Pretty, ConsoleReporter}
 import scala.annotation.tailrec
-import ScalaVersionSpecific._
 
 /** Helper class to satisfy ScalaJS compilation. Do not use this directly,
  *  use `Prop.apply` instead. */
@@ -750,7 +749,7 @@ object Prop {
   /** Universal quantifier for an explicit generator. Shrinks failed arguments
    *  with the given shrink function */
   def forAllShrink[T, P](g: Gen[T],
-    shrink: T => LazyList[T])(f: T => P
+    shrink: T => Stream[T])(f: T => P
   )(implicit pv: P => Prop, pp: T => Pretty
   ): Prop = Prop { prms0 =>
 
@@ -766,8 +765,8 @@ object Prop {
     /*
      * Returns the first failed result in Left or success in Right.
      */
-    def getFirstFailure(xs: LazyList[T]): Either[(T,Result),(T,Result)] = {
-      assert(!xs.isEmpty, "LazyList cannot be empty")
+    def getFirstFailure(xs: Stream[T]): Either[(T,Result),(T,Result)] = {
+      assert(!xs.isEmpty, "Stream cannot be empty")
       val results = xs.map(x => (x, result(x)))
       results.dropWhile(!_._2.failure).headOption match {
         case None => Right(results.head)

src/main/scala/org/scalacheck/Shrink.scala

@@ -14,60 +14,59 @@ import language.higherKinds
 import util.Buildable
 import util.SerializableCanBuildFroms._
 import scala.concurrent.duration.{Duration, FiniteDuration}
-import ScalaVersionSpecific._
 
 sealed abstract class Shrink[T] extends Serializable {
-  def shrink(x: T): LazyList[T]
+  def shrink(x: T): Stream[T]
 }
 
 trait ShrinkLowPriority {
   /** Default shrink instance */
-  implicit def shrinkAny[T]: Shrink[T] = Shrink(_ => LazyList.empty)
+  implicit def shrinkAny[T]: Shrink[T] = Shrink(_ => Stream.empty)
 }
 
 object Shrink extends ShrinkLowPriority {
 
-  import LazyList.{cons, empty}
+  import Stream.{cons, empty}
   import scala.collection._
 
-  /** Interleaves two streams / lazy lists */
-  private def interleave[T](xs: LazyList[T], ys: LazyList[T]): LazyList[T] =
+  /** Interleaves two streams */
+  private def interleave[T](xs: Stream[T], ys: Stream[T]): Stream[T] =
     if(xs.isEmpty) ys
     else if(ys.isEmpty) xs
     else cons(xs.head, cons(ys.head, interleave(xs.tail, ys.tail)))
 
   /** Shrink instance factory */
-  def apply[T](s: T => LazyList[T]): Shrink[T] = new Shrink[T] {
+  def apply[T](s: T => Stream[T]): Shrink[T] = new Shrink[T] {
     override def shrink(x: T) = s(x)
   }
 
   /** Shrink a value */
-  def shrink[T](x: T)(implicit s: Shrink[T]): LazyList[T] = s.shrink(x)
+  def shrink[T](x: T)(implicit s: Shrink[T]): Stream[T] = s.shrink(x)
 
   /** Shrink a value, but also return the original value as the first element in
-   *  the resulting stream / lazy list */
-  def shrinkWithOrig[T](x: T)(implicit s: Shrink[T]): LazyList[T] =
+   *  the resulting stream */
+  def shrinkWithOrig[T](x: T)(implicit s: Shrink[T]): Stream[T] =
     cons(x, s.shrink(x))
 
   /** Shrink instance of container */
   implicit def shrinkContainer[C[_],T](implicit v: C[T] => Traversable[T], s: Shrink[T],
     b: Buildable[T,C[T]]
   ): Shrink[C[T]] = Shrink { xs: C[T] =>
     val ys = v(xs)
-    val zs = toLazyList(ys)
-    removeChunks(ys.size,zs).lazyAppendedAll(shrinkOne(zs)).map(b.fromIterable)
+    val zs = ys.toStream
+    removeChunks(ys.size,zs).append(shrinkOne(zs)).map(b.fromIterable)
   }
 
   /** Shrink instance of container2 */
   implicit def shrinkContainer2[C[_,_],T,U](implicit v: C[T,U] => Traversable[(T,U)], s: Shrink[(T,U)],
     b: Buildable[(T,U),C[T,U]]
   ): Shrink[C[T,U]] = Shrink { xs: C[T,U] =>
     val ys = v(xs)
-    val zs = toLazyList(ys)
-    removeChunks(ys.size,zs).lazyAppendedAll(shrinkOne(zs)).map(b.fromIterable)
+    val zs = ys.toStream
+    removeChunks(ys.size,zs).append(shrinkOne(zs)).map(b.fromIterable)
   }
 
-  private def removeChunks[T](n: Int, xs: LazyList[T]): LazyList[LazyList[T]] =
+  private def removeChunks[T](n: Int, xs: Stream[T]): Stream[Stream[T]] =
     if (xs.isEmpty) empty
     else if (xs.tail.isEmpty) cons(empty, empty)
     else {
@@ -76,19 +75,19 @@ object Shrink extends ShrinkLowPriority {
       lazy val xs1 = xs.take(n1)
       lazy val xs2 = xs.drop(n1)
       lazy val xs3 =
-        for (ys1 <- removeChunks(n1, xs1) if !ys1.isEmpty) yield ys1 lazyAppendedAll xs2
+        for (ys1 <- removeChunks(n1, xs1) if !ys1.isEmpty) yield ys1 append xs2
       lazy val xs4 =
-        for (ys2 <- removeChunks(n2, xs2) if !ys2.isEmpty) yield xs1 lazyAppendedAll ys2
+        for (ys2 <- removeChunks(n2, xs2) if !ys2.isEmpty) yield xs1 append ys2
 
       cons(xs1, cons(xs2, interleave(xs3, xs4)))
     }
 
-  private def shrinkOne[T : Shrink](zs: LazyList[T]): LazyList[LazyList[T]] =
+  private def shrinkOne[T : Shrink](zs: Stream[T]): Stream[Stream[T]] =
     if (zs.isEmpty) empty
     else {
       val x = zs.head
       val xs = zs.tail
-      shrink(x).map(cons(_,xs)).lazyAppendedAll(shrinkOne(xs).map(cons(x,_)))
+      shrink(x).map(cons(_,xs)).append(shrinkOne(xs).map(cons(x,_)))
     }
 
   /** Shrink instances for numeric data types */
@@ -115,7 +114,7 @@ object Shrink extends ShrinkLowPriority {
     T1:Shrink, T2:Shrink
   ]: Shrink[(T1,T2)] =
     Shrink { case (t1,t2) =>
-      shrink(t1).map((_,t2)) lazyAppendedAll
+      shrink(t1).map((_,t2)) append
       shrink(t2).map((t1,_))
     }
 
@@ -124,8 +123,8 @@ object Shrink extends ShrinkLowPriority {
     T1:Shrink, T2:Shrink, T3:Shrink
   ]: Shrink[(T1,T2,T3)] =
     Shrink { case (t1,t2,t3) =>
-      shrink(t1).map((_, t2, t3)) lazyAppendedAll
-      shrink(t2).map((t1, _, t3)) lazyAppendedAll
+      shrink(t1).map((_, t2, t3)) append
+      shrink(t2).map((t1, _, t3)) append
       shrink(t3).map((t1, t2, _))
     }
 
@@ -134,9 +133,9 @@ object Shrink extends ShrinkLowPriority {
     T1:Shrink, T2:Shrink, T3:Shrink, T4:Shrink
   ]: Shrink[(T1,T2,T3,T4)] =
     Shrink { case (t1,t2,t3,t4) =>
-      shrink(t1).map((_, t2, t3, t4)) lazyAppendedAll
-      shrink(t2).map((t1, _, t3, t4)) lazyAppendedAll
-      shrink(t3).map((t1, t2, _, t4)) lazyAppendedAll
+      shrink(t1).map((_, t2, t3, t4)) append
+      shrink(t2).map((t1, _, t3, t4)) append
+      shrink(t3).map((t1, t2, _, t4)) append
       shrink(t4).map((t1, t2, t3, _))
     }
 
@@ -145,10 +144,10 @@ object Shrink extends ShrinkLowPriority {
     T1:Shrink, T2:Shrink, T3:Shrink, T4:Shrink, T5:Shrink
   ]: Shrink[(T1,T2,T3,T4,T5)] =
     Shrink { case (t1,t2,t3,t4,t5) =>
-      shrink(t1).map((_, t2, t3, t4, t5)) lazyAppendedAll
-      shrink(t2).map((t1, _, t3, t4, t5)) lazyAppendedAll
-      shrink(t3).map((t1, t2, _, t4, t5)) lazyAppendedAll
-      shrink(t4).map((t1, t2, t3, _, t5)) lazyAppendedAll
+      shrink(t1).map((_, t2, t3, t4, t5)) append
+      shrink(t2).map((t1, _, t3, t4, t5)) append
+      shrink(t3).map((t1, t2, _, t4, t5)) append
+      shrink(t4).map((t1, t2, t3, _, t5)) append
       shrink(t5).map((t1, t2, t3, t4, _))
     }
 
@@ -157,11 +156,11 @@ object Shrink extends ShrinkLowPriority {
     T1:Shrink, T2:Shrink, T3:Shrink, T4:Shrink, T5:Shrink, T6:Shrink
   ]: Shrink[(T1,T2,T3,T4,T5,T6)] =
     Shrink { case (t1,t2,t3,t4,t5,t6) =>
-      shrink(t1).map((_, t2, t3, t4, t5, t6)) lazyAppendedAll
-      shrink(t2).map((t1, _, t3, t4, t5, t6)) lazyAppendedAll
-      shrink(t3).map((t1, t2, _, t4, t5, t6)) lazyAppendedAll
-      shrink(t4).map((t1, t2, t3, _, t5, t6)) lazyAppendedAll
-      shrink(t5).map((t1, t2, t3, t4, _, t6)) lazyAppendedAll
+      shrink(t1).map((_, t2, t3, t4, t5, t6)) append
+      shrink(t2).map((t1, _, t3, t4, t5, t6)) append
+      shrink(t3).map((t1, t2, _, t4, t5, t6)) append
+      shrink(t4).map((t1, t2, t3, _, t5, t6)) append
+      shrink(t5).map((t1, t2, t3, t4, _, t6)) append
       shrink(t6).map((t1, t2, t3, t4, t5, _))
     }
 
@@ -170,12 +169,12 @@ object Shrink extends ShrinkLowPriority {
     T1:Shrink, T2:Shrink, T3:Shrink, T4:Shrink, T5:Shrink, T6:Shrink, T7:Shrink
   ]: Shrink[(T1,T2,T3,T4,T5,T6,T7)] =
     Shrink { case (t1,t2,t3,t4,t5,t6,t7) =>
-      shrink(t1).map((_, t2, t3, t4, t5, t6, t7)) lazyAppendedAll
-      shrink(t2).map((t1, _, t3, t4, t5, t6, t7)) lazyAppendedAll
-      shrink(t3).map((t1, t2, _, t4, t5, t6, t7)) lazyAppendedAll
-      shrink(t4).map((t1, t2, t3, _, t5, t6, t7)) lazyAppendedAll
-      shrink(t5).map((t1, t2, t3, t4, _, t6, t7)) lazyAppendedAll
-      shrink(t6).map((t1, t2, t3, t4, t5, _, t7)) lazyAppendedAll
+      shrink(t1).map((_, t2, t3, t4, t5, t6, t7)) append
+      shrink(t2).map((t1, _, t3, t4, t5, t6, t7)) append
+      shrink(t3).map((t1, t2, _, t4, t5, t6, t7)) append
+      shrink(t4).map((t1, t2, t3, _, t5, t6, t7)) append
+      shrink(t5).map((t1, t2, t3, t4, _, t6, t7)) append
+      shrink(t6).map((t1, t2, t3, t4, t5, _, t7)) append
       shrink(t7).map((t1, t2, t3, t4, t5, t6, _))
     }
 
@@ -185,13 +184,13 @@ object Shrink extends ShrinkLowPriority {
     T7:Shrink, T8:Shrink
   ]: Shrink[(T1,T2,T3,T4,T5,T6,T7,T8)] =
     Shrink { case (t1,t2,t3,t4,t5,t6,t7,t8) =>
-      shrink(t1).map((_, t2, t3, t4, t5, t6, t7, t8)) lazyAppendedAll
-      shrink(t2).map((t1, _, t3, t4, t5, t6, t7, t8)) lazyAppendedAll
-      shrink(t3).map((t1, t2, _, t4, t5, t6, t7, t8)) lazyAppendedAll
-      shrink(t4).map((t1, t2, t3, _, t5, t6, t7, t8)) lazyAppendedAll
-      shrink(t5).map((t1, t2, t3, t4, _, t6, t7, t8)) lazyAppendedAll
-      shrink(t6).map((t1, t2, t3, t4, t5, _, t7, t8)) lazyAppendedAll
-      shrink(t7).map((t1, t2, t3, t4, t5, t6, _, t8)) lazyAppendedAll
+      shrink(t1).map((_, t2, t3, t4, t5, t6, t7, t8)) append
+      shrink(t2).map((t1, _, t3, t4, t5, t6, t7, t8)) append
+      shrink(t3).map((t1, t2, _, t4, t5, t6, t7, t8)) append
+      shrink(t4).map((t1, t2, t3, _, t5, t6, t7, t8)) append
+      shrink(t5).map((t1, t2, t3, t4, _, t6, t7, t8)) append
+      shrink(t6).map((t1, t2, t3, t4, t5, _, t7, t8)) append
+      shrink(t7).map((t1, t2, t3, t4, t5, t6, _, t8)) append
       shrink(t8).map((t1, t2, t3, t4, t5, t6, t7, _))
     }
 
@@ -201,14 +200,14 @@ object Shrink extends ShrinkLowPriority {
     T7:Shrink, T8:Shrink, T9:Shrink
   ]: Shrink[(T1,T2,T3,T4,T5,T6,T7,T8,T9)] =
     Shrink { case (t1,t2,t3,t4,t5,t6,t7,t8,t9) =>
-      shrink(t1).map((_, t2, t3, t4, t5, t6, t7, t8, t9)) lazyAppendedAll
-      shrink(t2).map((t1, _, t3, t4, t5, t6, t7, t8, t9)) lazyAppendedAll
-      shrink(t3).map((t1, t2, _, t4, t5, t6, t7, t8, t9)) lazyAppendedAll
-      shrink(t4).map((t1, t2, t3, _, t5, t6, t7, t8, t9)) lazyAppendedAll
-      shrink(t5).map((t1, t2, t3, t4, _, t6, t7, t8, t9)) lazyAppendedAll
-      shrink(t6).map((t1, t2, t3, t4, t5, _, t7, t8, t9)) lazyAppendedAll
-      shrink(t7).map((t1, t2, t3, t4, t5, t6, _, t8, t9)) lazyAppendedAll
-      shrink(t8).map((t1, t2, t3, t4, t5, t6, t7, _, t9)) lazyAppendedAll
+      shrink(t1).map((_, t2, t3, t4, t5, t6, t7, t8, t9)) append
+      shrink(t2).map((t1, _, t3, t4, t5, t6, t7, t8, t9)) append
+      shrink(t3).map((t1, t2, _, t4, t5, t6, t7, t8, t9)) append
+      shrink(t4).map((t1, t2, t3, _, t5, t6, t7, t8, t9)) append
+      shrink(t5).map((t1, t2, t3, t4, _, t6, t7, t8, t9)) append
+      shrink(t6).map((t1, t2, t3, t4, t5, _, t7, t8, t9)) append
+      shrink(t7).map((t1, t2, t3, t4, t5, t6, _, t8, t9)) append
+      shrink(t8).map((t1, t2, t3, t4, t5, t6, t7, _, t9)) append
       shrink(t9).map((t1, t2, t3, t4, t5, t6, t7, t8, _))
     }
 
@@ -222,7 +221,7 @@ object Shrink extends ShrinkLowPriority {
 
   implicit val shrinkDuration: Shrink[Duration] = Shrink {
     case d: FiniteDuration => shrinkFiniteDuration.shrink(d)
-    case _ => LazyList.empty
+    case _ => Stream.empty
   }
 
   /** Transform a Shrink[T] to a Shrink[U] where T and U are two isomorphic types
@@ -245,15 +244,15 @@ final class ShrinkIntegral[T](implicit ev: Integral[T]) extends Shrink[T] {
   val skipNegation = gteq(negate(one), one)
 
   // assumes x is non-zero.
-  private def halves(x: T): LazyList[T] = {
+  private def halves(x: T): Stream[T] = {
     val q = quot(x, two)
-    if (equiv(q, zero)) LazyList(zero)
+    if (equiv(q, zero)) Stream(zero)
     else if (skipNegation) q #:: halves(q)
     else q #:: negate(q) #:: halves(q)
   }
 
-  def shrink(x: T): LazyList[T] =
-    if (equiv(x, zero)) LazyList.empty[T] else halves(x)
+  def shrink(x: T): Stream[T] =
+    if (equiv(x, zero)) Stream.empty[T] else halves(x)
 }
 
 final class ShrinkFractional[T](implicit ev: Fractional[T]) extends Shrink[T] {
@@ -268,9 +267,9 @@ final class ShrinkFractional[T](implicit ev: Fractional[T]) extends Shrink[T] {
   def closeToZero(x: T): Boolean = lteq(abs(x), small)
 
   // assumes x is not close to zero
-  private def halves(x: T): LazyList[T] = {
+  private def halves(x: T): Stream[T] = {
     val q = div(x, two)
-    if (closeToZero(q)) LazyList(zero)
+    if (closeToZero(q)) Stream(zero)
     else q #:: negate(q) #:: halves(q)
   }
 
@@ -283,7 +282,7 @@ final class ShrinkFractional[T](implicit ev: Fractional[T]) extends Shrink[T] {
     !lt(div(x, two), x)
   }
 
-  def shrink(x: T): LazyList[T] =
-    if (closeToZero(x) || isUnusual(x)) LazyList.empty[T]
+  def shrink(x: T): Stream[T] =
+    if (closeToZero(x) || isUnusual(x)) Stream.empty[T]
     else halves(x)
 }

src/main/scala/org/scalacheck/commands/Commands.scala

@@ -11,7 +11,6 @@ package org.scalacheck.commands
 
 import org.scalacheck._
 import scala.util.{Try, Success, Failure}
-import ScalaVersionSpecific._
 
 /** An API for stateful testing in ScalaCheck.
  *
@@ -271,8 +270,8 @@ trait Commands {
   )
 
   private implicit val shrinkActions = Shrink[Actions] { as =>
-    val shrinkedCmds: LazyList[Actions] =
-      Shrink.shrink(as.seqCmds).map(cs => as.copy(seqCmds = cs)) lazyAppendedAll
+    val shrinkedCmds: Stream[Actions] =
+      Shrink.shrink(as.seqCmds).map(cs => as.copy(seqCmds = cs)) append
       Shrink.shrink(as.parCmds).map(cs => as.copy(parCmds = cs))
 
     Shrink.shrinkWithOrig[State](as.s)(shrinkState) flatMap { state =>

src/test/scala/org/scalacheck/ShrinkSpecification.scala

@@ -17,10 +17,10 @@ import scala.concurrent.duration.{Duration, FiniteDuration}
 
 object ShrinkSpecification extends Properties("Shrink") {
 
-  def shrinkClosure[T : Shrink](x: T): LazyList[T] = {
+  def shrinkClosure[T : Shrink](x: T): Stream[T] = {
     val xs = shrink[T](x)
     if(xs.isEmpty) xs
-    else xs.lazyAppendedAll(xs.take(1).map(shrinkClosure[T]).flatten)
+    else xs.append(xs.take(1).map(shrinkClosure[T]).flatten)
   }
 
   property("byte") = forAll { n: Byte =>
@@ -105,7 +105,7 @@ object ShrinkSpecification extends Properties("Shrink") {
 
   /* Ensure that shrink[T] terminates. (#244)
    *
-   * Let's say shrinking "terminates" when the stream / lazy list of values
+   * Let's say shrinking "terminates" when the stream of values
    * becomes empty. We can empirically determine the longest possible
    * sequence for a given type before termination. (Usually this
    * involves using the type's MinValue.)