Merge pull request #1345 from non/topic/scalacheck-1.13.x

Bump ScalaCheck to 1.13.1, and fix the fallout.

build.sbt

@@ -94,7 +94,8 @@ lazy val commonJsSettings = Seq(
   botBuild := scala.sys.env.get("TRAVIS").isDefined,
   // batch mode decreases the amount of memory needed to compile scala.js code
   scalaJSOptimizerOptions := scalaJSOptimizerOptions.value.withBatchMode(botBuild.value),
-  doctestGenTests := Seq.empty
+  doctestGenTests := Seq.empty,
+  doctestWithDependencies := false
 )
 
 lazy val commonJvmSettings = Seq(
@@ -114,16 +115,18 @@ lazy val includeGeneratedSrc: Setting[_] = {
 
 lazy val catsSettings = buildSettings ++ commonSettings ++ publishSettings ++ scoverageSettings ++ javadocSettings
 
-lazy val scalacheckVersion = "1.12.5"
+lazy val scalaCheckVersion = "1.13.2"
+lazy val scalaTestVersion = "3.0.0"
+lazy val disciplineVersion = "0.6"
 
 lazy val disciplineDependencies = Seq(
-  libraryDependencies += "org.scalacheck" %%% "scalacheck" % scalacheckVersion,
-  libraryDependencies += "org.typelevel" %%% "discipline" % "0.4")
+  libraryDependencies += "org.scalacheck" %%% "scalacheck" % scalaCheckVersion,
+  libraryDependencies += "org.typelevel" %%% "discipline" % disciplineVersion)
 
 lazy val testingDependencies = Seq(
   libraryDependencies += "org.typelevel" %%% "catalysts-platform" % "0.0.2",
   libraryDependencies += "org.typelevel" %%% "catalysts-macros" % "0.0.2" % "test",
-  libraryDependencies += "org.scalatest" %%% "scalatest" % "3.0.0-M8" % "test")
+  libraryDependencies += "org.scalatest" %%% "scalatest" % scalaTestVersion % "test")
 
 
 /**
@@ -246,7 +249,7 @@ lazy val core = crossProject.crossType(CrossType.Pure)
   .settings(catsSettings:_*)
   .settings(sourceGenerators in Compile <+= (sourceManaged in Compile).map(Boilerplate.gen))
   .settings(includeGeneratedSrc)
-  .settings(libraryDependencies += "org.scalacheck" %%% "scalacheck" % scalacheckVersion % "test")
+  .settings(libraryDependencies += "org.scalacheck" %%% "scalacheck" % scalaCheckVersion % "test")
   .jsSettings(commonJsSettings:_*)
   .jvmSettings(commonJvmSettings:_*)
 

free/src/test/scala/cats/free/FreeTTests.scala

@@ -8,7 +8,7 @@ import cats.laws.discipline._
 import cats.tests.CatsSuite
 import cats.instances.option._
 
-import org.scalacheck.{Arbitrary, Gen}
+import org.scalacheck.{Arbitrary, Gen, Cogen}
 
 class FreeTTests extends CatsSuite {
 
@@ -165,7 +165,7 @@ object FreeTTests extends FreeTTestsInstances {
     def withFlatMapped = for {
       fDepth <- nextDepth
       freeDepth <- nextDepth
-      f <- arbFunction1[A, FreeT[F, G, A]](Arbitrary(freeTGen[F, G, A](fDepth))).arbitrary
+      f <- arbFunction1[A, FreeT[F, G, A]](Arbitrary(freeTGen[F, G, A](fDepth)), Cogen[Unit].contramap(_ => ())).arbitrary
       freeFGA <- freeTGen[F, G, A](freeDepth)
     } yield freeFGA.flatMap(f)
 

free/src/test/scala/cats/free/FreeTests.scala

@@ -6,7 +6,7 @@ import cats.arrow.FunctionK
 import cats.laws.discipline.{CartesianTests, MonadTests, SerializableTests}
 import cats.laws.discipline.arbitrary.catsLawsArbitraryForFn0
 
-import org.scalacheck.{Arbitrary, Gen}
+import org.scalacheck.{Arbitrary, Gen, Cogen}
 import Arbitrary.arbFunction1
 
 class FreeTests extends CatsSuite {
@@ -131,7 +131,7 @@ sealed trait FreeTestsInstances {
     def withFlatMapped = for {
       fDepth <- nextDepth
       freeDepth <- nextDepth
-      f <- arbFunction1[A, Free[F, A]](Arbitrary(freeGen[F, A](fDepth))).arbitrary
+      f <- arbFunction1[A, Free[F, A]](Arbitrary(freeGen[F, A](fDepth)), Cogen[Unit].contramap(_ => ())).arbitrary
       freeFA <- freeGen[F, A](freeDepth)
     } yield freeFA.flatMap(f)
 

js/src/test/scala/cats/tests/FutureTests.scala

@@ -10,8 +10,9 @@ import cats.tests.CatsSuite
 import scala.concurrent.Future
 import scala.concurrent.duration._
 
-import org.scalacheck.Arbitrary
+import org.scalacheck.{Arbitrary, Cogen}
 import org.scalacheck.Arbitrary.arbitrary
+import cats.laws.discipline.arbitrary._
 
 // https://issues.scala-lang.org/browse/SI-7934
 @deprecated("", "")
@@ -36,14 +37,20 @@ class FutureTests extends CatsSuite {
     }
 
   implicit val throwableEq: Eq[Throwable] =
-    Eq.fromUniversalEquals
+    Eq[String].on(_.toString)
 
   implicit val comonad: Comonad[Future] = futureComonad(timeout)
 
   // Need non-fatal Throwables for Future recoverWith/handleError
   implicit val nonFatalArbitrary: Arbitrary[Throwable] =
     Arbitrary(arbitrary[Exception].map(identity))
 
+  // We can't block on futures in JS, so we can't create interesting
+  // cogen instances. This will allow the tests to run in a
+  // less-useful way.
+  implicit def cogenForFuture[A]: Cogen[Future[A]] =
+    Cogen[Unit].contramap(_ => ())
+
   checkAll("Future[Int]", MonadErrorTests[Future, Throwable].monadError[Int, Int, Int])
   checkAll("Future[Int]", ComonadTests[Future].comonad[Int, Int, Int])
   checkAll("Future", MonadTests[Future].monad[Int, Int, Int])

jvm/src/test/scala/cats/tests/FutureTests.scala

@@ -3,6 +3,7 @@ package jvm
 package tests
 
 import cats.laws.discipline._
+import cats.laws.discipline.arbitrary._
 import cats.tests.CatsSuite
 
 import scala.concurrent.{Await, Future}
@@ -27,7 +28,7 @@ class FutureTests extends CatsSuite {
     }
 
   implicit val throwableEq: Eq[Throwable] =
-    Eq.fromUniversalEquals
+    Eq[String].on(_.toString)
 
   // Need non-fatal Throwables for Future recoverWith/handleError
   implicit val nonFatalArbitrary: Arbitrary[Throwable] =

kernel-laws/src/main/scala/cats/kernel/laws/OrderLaws.scala

@@ -3,22 +3,25 @@ package laws
 
 import org.typelevel.discipline.Laws
 
-import org.scalacheck.{Arbitrary, Prop}
+import org.scalacheck.{Arbitrary, Cogen, Prop}
 import org.scalacheck.Prop._
 
 import cats.kernel.instances.all._
 
 object OrderLaws {
-  def apply[A: Eq: Arbitrary]: OrderLaws[A] = new OrderLaws[A] {
-    def Equ = Eq[A]
-    def Arb = implicitly[Arbitrary[A]]
-  }
+  def apply[A: Eq: Arbitrary: Cogen]: OrderLaws[A] =
+    new OrderLaws[A] {
+      def Equ = Eq[A]
+      def Arb = implicitly[Arbitrary[A]]
+      def Cog = implicitly[Cogen[A]]
+    }
 }
 
 trait OrderLaws[A] extends Laws {
 
   implicit def Equ: Eq[A]
   implicit def Arb: Arbitrary[A]
+  implicit def Cog: Cogen[A]
 
   def eqv: OrderProperties = new OrderProperties(
     name = "eq",

kernel-laws/src/test/scala/cats/kernel/laws/LawTests.scala

@@ -8,7 +8,7 @@ import cats.kernel.instances.all._
 
 import org.typelevel.discipline.{ Laws }
 import org.typelevel.discipline.scalatest.Discipline
-import org.scalacheck.{ Arbitrary, Gen }
+import org.scalacheck.{ Arbitrary, Cogen, Gen }
 import Arbitrary.arbitrary
 import org.scalatest.FunSuite
 
@@ -24,13 +24,28 @@ class LawTests extends FunSuite with Discipline {
   implicit override val generatorDrivenConfig: PropertyCheckConfiguration =
     PropertyCheckConfig(maxSize = PropMaxSize, minSuccessful = PropMinSuccessful)
 
-  implicit def orderLaws[A: Eq: Arbitrary] = OrderLaws[A]
-  implicit def groupLaws[A: Eq: Arbitrary] = GroupLaws[A]
+  implicit def orderLaws[A: Cogen: Eq: Arbitrary]: OrderLaws[A] = OrderLaws[A]
+  implicit def groupLaws[A: Cogen: Eq: Arbitrary]: GroupLaws[A] = GroupLaws[A]
 
   implicit val arbitraryBitSet: Arbitrary[BitSet] =
     Arbitrary(arbitrary[List[Short]].map(ns => BitSet(ns.map(_ & 0xffff): _*)))
 
-  laws[OrderLaws, Map[String, HasEq[Int]]].check(_.eqv)
+  // this instance is not available in scalacheck 1.13.2.
+  // remove this once a newer version is available.
+  implicit val cogenBigInt: Cogen[BigInt] =
+    Cogen[Long].contramap(_.toLong)
+
+  // this instance is not available in scalacheck 1.13.2.
+  // remove this once a newer version is available.
+  implicit val cogenBigDecimal: Cogen[BigDecimal] =
+    Cogen[Double].contramap(_.toDouble)
+
+  {
+    // needed for Cogen[Map[...]]
+    implicit val ohe: Ordering[HasEq[Int]] = Ordering[Int].on(_.a)
+    laws[OrderLaws, Map[String, HasEq[Int]]].check(_.eqv)
+  }
+
   laws[OrderLaws, List[HasEq[Int]]].check(_.eqv)
   laws[OrderLaws, Option[HasEq[Int]]].check(_.eqv)
   laws[OrderLaws, Vector[HasEq[Int]]].check(_.eqv)
@@ -114,6 +129,9 @@ class LawTests extends FunSuite with Discipline {
   implicit val arbitraryComparison: Arbitrary[Comparison] =
     Arbitrary(Gen.oneOf(Comparison.GreaterThan, Comparison.EqualTo, Comparison.LessThan))
 
+  implicit val cogenComparison: Cogen[Comparison] =
+    Cogen[Int].contramap(_.toInt)
+
   laws[OrderLaws, Comparison].check(_.eqv)
 
   test("comparison") {
@@ -168,12 +186,16 @@ class LawTests extends FunSuite with Discipline {
       val order = new Random(seed).shuffle(Vector.range(0, nMax))
       Order.by { (n: N) => order(n.n) }
     })
+    implicit val cogNOrder: Cogen[Order[N]] =
+      Cogen[Unit].contramap(_ => ())
     // The arbitrary `Eq[N]` values are created by mapping N values to random
     // integers.
     implicit val arbNEq: Arbitrary[Eq[N]] = Arbitrary(arbitrary[Int].map { seed =>
       val mapping = new Random(seed).shuffle(Vector.range(0, nMax))
       Eq.by { (n: N) => mapping(n.n) }
     })
+    implicit val cogNEq: Cogen[Eq[N]] =
+      Cogen[Unit].contramap(_ => ())
     // needed because currently we don't have Vector instances
     implicit val vectorNEq: Eq[Vector[N]] = Eq.fromUniversalEquals
     // The `Eq[Order[N]]` instance enumerates all possible `N` values in a
@@ -210,6 +232,8 @@ class LawTests extends FunSuite with Discipline {
       Eq[A].on(_.a)
     implicit def hasEqArbitrary[A: Arbitrary]: Arbitrary[HasEq[A]] =
       Arbitrary(arbitrary[A].map(HasEq(_)))
+    implicit def hasCogen[A: Cogen]: Cogen[HasEq[A]] =
+      Cogen[A].contramap(_.a)
   }
 
   case class HasPartialOrder[A](a: A)
@@ -219,6 +243,8 @@ class LawTests extends FunSuite with Discipline {
       PartialOrder[A].on(_.a)
     implicit def hasPartialOrderArbitrary[A: Arbitrary]: Arbitrary[HasPartialOrder[A]] =
       Arbitrary(arbitrary[A].map(HasPartialOrder(_)))
+    implicit def hasCogen[A: Cogen]: Cogen[HasPartialOrder[A]] =
+      Cogen[A].contramap(_.a)
   }
 
   case class LawChecker[L <: Laws](name: String, laws: L) {

laws/src/main/scala/cats/laws/MonadCombineLaws.scala

@@ -1,16 +1,24 @@
 package cats
 package laws
 
-import cats.syntax.all._
+// import cats.syntax.all._
 
 /**
  * Laws that must be obeyed by any `MonadCombine`.
  */
 trait MonadCombineLaws[F[_]] extends MonadFilterLaws[F] with AlternativeLaws[F] {
   implicit override def F: MonadCombine[F]
 
-  def monadCombineLeftDistributivity[A, B](fa: F[A], fa2: F[A], f: A => F[B]): IsEq[F[B]] =
-    F.combineK(fa, fa2).flatMap(f) <-> F.combineK(fa flatMap f, fa2 flatMap f)
+  // the left distributivity law does not hold for things like
+  // MonadCombine[Option]; here's a counter-example:
+  //
+  //     def f(x: Int): Option[Int] = if (x == 0) None else Some(x)
+  //     val a = Option(0)
+  //     val b = Option(1)
+  //     (a <+> b).flatMap(f) != (a.flatMap(f) <+> b.flatMap(f))
+  //
+  // def monadCombineLeftDistributivity[A, B](fa: F[A], fa2: F[A], f: A => F[B]): IsEq[F[B]] =
+  //   F.combineK(fa, fa2).flatMap(f) <-> F.combineK(fa flatMap f, fa2 flatMap f)
 }
 
 object MonadCombineLaws {

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

@@ -3,8 +3,7 @@ package laws
 package discipline
 
 import cats.laws.discipline.CartesianTests.Isomorphisms
-import org.scalacheck.Arbitrary
-import org.scalacheck.Prop
+import org.scalacheck.{Arbitrary, Cogen, Prop}
 import Prop._
 
 trait AlternativeTests[F[_]] extends ApplicativeTests[F] with MonoidKTests[F]  {
@@ -16,6 +15,9 @@ trait AlternativeTests[F[_]] extends ApplicativeTests[F] with MonoidKTests[F]  {
     ArbFC: Arbitrary[F[C]],
     ArbFAtoB: Arbitrary[F[A => B]],
     ArbFBtoC: Arbitrary[F[B => C]],
+    CogenA: Cogen[A],
+    CogenB: Cogen[B],
+    CogenC: Cogen[C],
     EqFA: Eq[F[A]],
     EqFB: Eq[F[B]],
     EqFC: Eq[F[C]],

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

@@ -5,7 +5,7 @@ package discipline
 import cats.data.EitherT
 import cats.laws.discipline.CartesianTests.Isomorphisms
 import cats.laws.discipline.arbitrary._
-import org.scalacheck.{Arbitrary, Prop}
+import org.scalacheck.{Arbitrary, Cogen, Prop}
 import org.scalacheck.Prop.forAll
 
 trait ApplicativeErrorTests[F[_], E] extends ApplicativeTests[F] {
@@ -18,6 +18,10 @@ trait ApplicativeErrorTests[F[_], E] extends ApplicativeTests[F] {
     ArbFAtoB: Arbitrary[F[A => B]],
     ArbFBtoC: Arbitrary[F[B => C]],
     ArbE: Arbitrary[E],
+    CogenA: Cogen[A],
+    CogenB: Cogen[B],
+    CogenC: Cogen[C],
+    CogenE: Cogen[E],
     EqFA: Eq[F[A]],
     EqFB: Eq[F[B]],
     EqFC: Eq[F[C]],

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

@@ -3,8 +3,7 @@ package laws
 package discipline
 
 import cats.laws.discipline.CartesianTests.Isomorphisms
-import org.scalacheck.Arbitrary
-import org.scalacheck.Prop
+import org.scalacheck.{Arbitrary, Cogen, Prop}
 import Prop._
 
 trait ApplicativeTests[F[_]] extends ApplyTests[F] {
@@ -16,6 +15,9 @@ trait ApplicativeTests[F[_]] extends ApplyTests[F] {
     ArbFC: Arbitrary[F[C]],
     ArbFAtoB: Arbitrary[F[A => B]],
     ArbFBtoC: Arbitrary[F[B => C]],
+    CogenA: Cogen[A],
+    CogenB: Cogen[B],
+    CogenC: Cogen[C],
     EqFA: Eq[F[A]],
     EqFB: Eq[F[B]],
     EqFC: Eq[F[C]],

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

@@ -3,8 +3,7 @@ package laws
 package discipline
 
 import cats.laws.discipline.CartesianTests.Isomorphisms
-import org.scalacheck.Arbitrary
-import org.scalacheck.Prop
+import org.scalacheck.{Arbitrary, Cogen, Prop}
 import Prop._
 
 trait ApplyTests[F[_]] extends FunctorTests[F] with CartesianTests[F] {
@@ -16,6 +15,9 @@ trait ApplyTests[F[_]] extends FunctorTests[F] with CartesianTests[F] {
     ArbFC: Arbitrary[F[C]],
     ArbFAtoB: Arbitrary[F[A => B]],
     ArbFBtoC: Arbitrary[F[B => C]],
+    CogenA: Cogen[A],
+    CogenB: Cogen[B],
+    CogenC: Cogen[C],
     EqFA: Eq[F[A]],
     EqFC: Eq[F[C]],
     EqFABC: Eq[F[(A, B, C)]],