replace Stream in ExhaustiveCheck with List

build.sbt

@@ -38,21 +38,23 @@ crossScalaVersionsFromTravis in Global := {
   }
 }
 
+def scalaVersionSpecificFolders(srcName: String, srcBaseDir: java.io.File, scalaVersion: String) = {
+  def extraDirs(suffix: String) =
+    CrossType.Pure.sharedSrcDir(srcBaseDir, "main").toList.map(f => file(f.getPath + suffix))
+  CrossVersion.partialVersion(scalaVersion) match {
+    case Some((2, y)) if y <= 12 =>
+      extraDirs("-2.12-")
+    case Some((2, y)) if y >= 13 =>
+      extraDirs("-2.13+")
+    case _ => Nil
+  }
+}
+
 lazy val commonSettings = Seq(
   crossScalaVersions := (crossScalaVersionsFromTravis in Global).value,
   scalacOptions ++= commonScalacOptions(scalaVersion.value),
-  Compile / unmanagedSourceDirectories ++= {
-    val bd = baseDirectory.value
-    def extraDirs(suffix: String) =
-      CrossType.Pure.sharedSrcDir(bd, "main").toList.map(f => file(f.getPath + suffix))
-    CrossVersion.partialVersion(scalaVersion.value) match {
-      case Some((2, y)) if y <= 12 =>
-        extraDirs("-2.12-")
-      case Some((2, y)) if y >= 13 =>
-        extraDirs("-2.13+")
-      case _ => Nil
-    }
-  },
+  Compile / unmanagedSourceDirectories ++= scalaVersionSpecificFolders("main", baseDirectory.value, scalaVersion.value),
+  Test / unmanagedSourceDirectories ++= scalaVersionSpecificFolders("test", baseDirectory.value, scalaVersion.value),
   resolvers ++= Seq(Resolver.sonatypeRepo("releases"), Resolver.sonatypeRepo("snapshots")),
   parallelExecution in Test := false,
   scalacOptions in (Compile, doc) := (scalacOptions in (Compile, doc)).value.filter(_ != "-Xfatal-warnings"),
@@ -801,13 +803,13 @@ def commonScalacOptions(scalaVersion: String) =
     "-unchecked",
     "-Ywarn-dead-code",
     "-Ywarn-numeric-widen",
-    "-Ywarn-value-discard",
-    "-Xfuture"
+    "-Ywarn-value-discard"
   ) ++ (if (priorTo2_13(scalaVersion))
           Seq(
             "-Yno-adapted-args",
             "-Xfatal-warnings", // TODO: add the following two back to 2.13
-            "-deprecation"
+            "-deprecation",
+            "-Xfuture"
           )
         else
           Seq(

core/src/main/scala/cats/instances/symbol.scala → core/src/main/scala/cats/instances/SymbolInstances.scala

@@ -1,7 +1,6 @@
-package cats
-package instances
+package cats.instances
 
-package object symbol extends SymbolInstances
+import cats.Show
 
 trait SymbolInstances extends cats.kernel.instances.SymbolInstances {
   implicit val catsStdShowForSymbol: Show[Symbol] =

core/src/main/scala/cats/instances/symbol/package.scala

@@ -0,0 +1,4 @@
+package cats
+package instances
+
+package object symbol extends SymbolInstances

laws/src/main/scala/cats/laws/discipline/ExhaustiveCheck.scala

@@ -8,18 +8,18 @@ package discipline
  * domain of values as opposed to generating a random sampling of values.
  */
 trait ExhaustiveCheck[A] extends Serializable { self =>
-  def allValues: Stream[A]
+  def allValues: List[A]
 }
 
 object ExhaustiveCheck {
   def apply[A](implicit A: ExhaustiveCheck[A]): ExhaustiveCheck[A] = A
 
-  def instance[A](values: Stream[A]): ExhaustiveCheck[A] = new ExhaustiveCheck[A] {
-    val allValues: Stream[A] = values
+  def instance[A](values: List[A]): ExhaustiveCheck[A] = new ExhaustiveCheck[A] {
+    val allValues: List[A] = values
   }
 
   implicit val catsLawsExhaustiveCheckForBoolean: ExhaustiveCheck[Boolean] =
-    instance(Stream(false, true))
+    instance(List(false, true))
 
   implicit val catsLawsExhaustiveCheckForSetBoolean: ExhaustiveCheck[Set[Boolean]] =
     forSet[Boolean]
@@ -50,13 +50,13 @@ object ExhaustiveCheck {
     instance(A.allValues.map(Left(_)) ++ B.allValues.map(Right(_)))
 
   implicit def catsLawsExhaustiveCheckForOption[A](implicit A: ExhaustiveCheck[A]): ExhaustiveCheck[Option[A]] =
-    instance(Stream.cons(None, A.allValues.map(Some(_))))
+    instance(None :: A.allValues.map(Some(_)))
 
   /**
    * Creates an `ExhaustiveCheck[Set[A]]` given an `ExhaustiveCheck[A]` by computing the powerset of
    * values. Note that if there are `n` elements in the domain of `A` there will be `2^n` elements
    * in the domain of `Set[A]`, so use this only on small domains.
    */
   def forSet[A](implicit A: ExhaustiveCheck[A]): ExhaustiveCheck[Set[A]] =
-    instance(A.allValues.toSet.subsets.toStream)
+    instance(A.allValues.toSet.subsets.toList)
 }

laws/src/main/scala/cats/laws/discipline/MiniInt.scala

@@ -49,7 +49,7 @@ object MiniInt {
       new MiniInt(i << intShift >>> intShift)
     } else throw new IllegalArgumentException(s"Expected value between $minIntValue and $maxIntValue but got $i")
 
-  val allValues: Stream[MiniInt] = (minIntValue to maxIntValue).map(unsafeFromInt).toStream
+  val allValues: List[MiniInt] = (minIntValue to maxIntValue).map(unsafeFromInt).toList
 
   implicit val catsLawsEqInstancesForMiniInt: Order[MiniInt] with Hash[MiniInt] = new Order[MiniInt]
   with Hash[MiniInt] {
@@ -58,7 +58,7 @@ object MiniInt {
     def compare(x: MiniInt, y: MiniInt): Int = Order[Int].compare(x.toInt, y.toInt)
   }
 
-  implicit val catsLawsExhuastiveCheckForMiniInt: ExhaustiveCheck[MiniInt] =
+  implicit val catsLawsExhaustiveCheckForMiniInt: ExhaustiveCheck[MiniInt] =
     ExhaustiveCheck.instance(allValues)
 
   val miniIntAddition: CommutativeGroup[MiniInt] = new CommutativeGroup[MiniInt] {

tests/src/test/scala/cats/tests/BinCodecInvariantMonoidalSuite.scala

@@ -51,8 +51,8 @@ object BinCodecInvariantMonoidalSuite {
     implicit val exhaustiveCheckForMiniListBoolean: ExhaustiveCheck[MiniList[Boolean]] =
       ExhaustiveCheck.instance(
         for {
-          length <- (0 to maxLength).toStream
-          boolList <- List(false, true).replicateA(length).toStream
+          length <- (0 to maxLength).toList
+          boolList <- List(false, true).replicateA(length)
         } yield MiniList.unsafe(boolList)
       )
   }

tests/src/test/scala/cats/tests/NonEmptySetSuite.scala

@@ -21,7 +21,7 @@ import cats.laws.discipline._
 import cats.laws.discipline.arbitrary._
 import cats.data.NonEmptySet
 import cats.kernel.Semilattice
-import cats.kernel.laws.discipline.{EqTests, OrderTests, PartialOrderTests, SemilatticeTests}
+import cats.kernel.laws.discipline.{EqTests, OrderTests, SemilatticeTests}
 
 import scala.collection.immutable.SortedSet