diff --git a/core/src/main/scala-2.12/cats/instances/all.scala b/core/src/main/scala-2.12/cats/instances/all.scala index 98110d1a4c..1628094e95 100644 --- a/core/src/main/scala-2.12/cats/instances/all.scala +++ b/core/src/main/scala-2.12/cats/instances/all.scala @@ -56,6 +56,7 @@ trait AllInstances with PartialOrderingInstances with QueueInstances with SetInstances + with ShowInstances with SortedMapInstances with SortedSetInstances with StreamInstances diff --git a/core/src/main/scala-2.12/cats/instances/package.scala b/core/src/main/scala-2.12/cats/instances/package.scala index 2e4b5287d6..1c54805005 100644 --- a/core/src/main/scala-2.12/cats/instances/package.scala +++ b/core/src/main/scala-2.12/cats/instances/package.scala @@ -66,6 +66,7 @@ package object instances { object set extends SetInstances object seq extends SeqInstances object short extends ShortInstances + object show extends ShowInstances object sortedMap extends SortedMapInstances with SortedMapInstancesBinCompat0 diff --git a/core/src/main/scala-2.13+/cats/instances/all.scala b/core/src/main/scala-2.13+/cats/instances/all.scala index 2f3371ab16..f57d80ac52 100644 --- a/core/src/main/scala-2.13+/cats/instances/all.scala +++ b/core/src/main/scala-2.13+/cats/instances/all.scala @@ -61,6 +61,7 @@ trait AllInstances with SetInstances with SortedMapInstances with SortedSetInstances + with ShowInstances with StreamInstances with StringInstances with SymbolInstances diff --git a/core/src/main/scala-2.13+/cats/instances/package.scala b/core/src/main/scala-2.13+/cats/instances/package.scala index f6668823d9..2ee72b37db 100644 --- a/core/src/main/scala-2.13+/cats/instances/package.scala +++ b/core/src/main/scala-2.13+/cats/instances/package.scala @@ -67,6 +67,7 @@ package object instances { object set extends SetInstances object seq extends SeqInstances object short extends ShortInstances + object show extends ShowInstances object sortedMap extends SortedMapInstances with SortedMapInstancesBinCompat0 diff --git a/core/src/main/scala/cats/Defer.scala b/core/src/main/scala/cats/Defer.scala index 6a109bd358..01adbee1d7 100644 --- a/core/src/main/scala/cats/Defer.scala +++ b/core/src/main/scala/cats/Defer.scala @@ -77,7 +77,16 @@ trait Defer[F[_]] extends Serializable { object Defer { def apply[F[_]](implicit defer: Defer[F]): Defer[F] = defer + implicit def catsDeferForEq: Defer[Eq] = cats.implicits.catsDeferForEq + implicit def catsDeferForEquiv: Defer[Equiv] = cats.implicits.catsDeferForEquiv implicit def catsDeferForFunction0: Defer[Function0] = cats.instances.function.catsSddDeferForFunction0 implicit def catsDeferForFunction1[A]: Defer[Function1[A, *]] = cats.instances.function.catsStdDeferForFunction1[A] + implicit def catsDeferForHash: Defer[Hash] = cats.implicits.catsDeferForHash + implicit def catsDeferForOrder: Defer[Order] = cats.instances.order.catsDeferForOrder + implicit def catsStdDeferForOrdering: Defer[Ordering] = cats.instances.ordering.catsStdDeferForOrdering + implicit def catsDeferForPartialOrder: Defer[PartialOrder] = cats.instances.partialOrder.catsDeferForPartialOrder + implicit def catsStdDeferForPartialOrdering: Defer[PartialOrdering] = + cats.instances.partialOrdering.catsStdDeferForPartialOrdering + implicit def catsDeferForShow: Defer[Show] = cats.implicits.catsDeferForShow implicit def catsDeferForTailRec: Defer[TailRec] = cats.instances.tailRec.catsInstancesForTailRec } diff --git a/core/src/main/scala/cats/instances/eq.scala b/core/src/main/scala/cats/instances/eq.scala index 2bd862ec08..5c96a8c219 100644 --- a/core/src/main/scala/cats/instances/eq.scala +++ b/core/src/main/scala/cats/instances/eq.scala @@ -22,6 +22,8 @@ package cats package instances +import scala.annotation.tailrec + trait EqInstances extends kernel.instances.EqInstances { implicit val catsContravariantMonoidalForEq: ContravariantMonoidal[Eq] = new ContravariantMonoidal[Eq] { @@ -43,4 +45,29 @@ trait EqInstances extends kernel.instances.EqInstances { def product[A, B](fa: Eq[A], fb: Eq[B]): Eq[(A, B)] = (left, right) => fa.eqv(left._1, right._1) && fb.eqv(left._2, right._2) } + + implicit def catsDeferForEq: Defer[Eq] = EqInstances.catsDeferForEqCache +} +object EqInstances { + private val catsDeferForEqCache: Defer[Eq] = + new Defer[Eq] { + case class Deferred[A](fa: () => Eq[A]) extends Eq[A] { + private lazy val resolved: Eq[A] = { + @tailrec + def loop(f: () => Eq[A]): Eq[A] = + f() match { + case Deferred(f) => loop(f) + case next => next + } + + loop(fa) + } + override def eqv(x: A, y: A): Boolean = resolved.eqv(x, y) + } + + override def defer[A](fa: => Eq[A]): Eq[A] = { + lazy val cachedFa = fa + Deferred(() => cachedFa) + } + } } diff --git a/core/src/main/scala/cats/instances/equiv.scala b/core/src/main/scala/cats/instances/equiv.scala index 19916ab3f9..941fd6e911 100644 --- a/core/src/main/scala/cats/instances/equiv.scala +++ b/core/src/main/scala/cats/instances/equiv.scala @@ -22,6 +22,8 @@ package cats package instances +import scala.annotation.tailrec + trait EquivInstances { implicit val catsContravariantMonoidalForEquiv: ContravariantMonoidal[Equiv] = new ContravariantMonoidal[Equiv] { @@ -52,4 +54,29 @@ trait EquivInstances { fa.equiv(l._1, r._1) && fb.equiv(l._2, r._2) } } + + implicit def catsDeferForEquiv: Defer[Equiv] = EquivInstances.catsDeferForEquivCache +} +object EquivInstances { + private val catsDeferForEquivCache: Defer[Equiv] = + new Defer[Equiv] { + case class Deferred[A](fa: () => Equiv[A]) extends Equiv[A] { + private lazy val resolved: Equiv[A] = { + @tailrec + def loop(f: () => Equiv[A]): Equiv[A] = + f() match { + case Deferred(f) => loop(f) + case next => next + } + + loop(fa) + } + override def equiv(x: A, y: A): Boolean = resolved.equiv(x, y) + } + + override def defer[A](fa: => Equiv[A]): Equiv[A] = { + lazy val cachedFa = fa + Deferred(() => cachedFa) + } + } } diff --git a/core/src/main/scala/cats/instances/function.scala b/core/src/main/scala/cats/instances/function.scala index 29a07db641..4233cd10a8 100644 --- a/core/src/main/scala/cats/instances/function.scala +++ b/core/src/main/scala/cats/instances/function.scala @@ -46,15 +46,17 @@ private[instances] trait FunctionInstancesBinCompat0 { implicit val catsSddDeferForFunction0: Defer[Function0] = new Defer[Function0] { case class Deferred[A](fa: () => Function0[A]) extends Function0[A] { - def apply() = { + private lazy val resolved: Function0[A] = { @annotation.tailrec - def loop(f: () => Function0[A]): A = + def loop(f: () => Function0[A]): Function0[A] = f() match { case Deferred(f) => loop(f) - case next => next() + case next => next } + loop(fa) } + def apply(): A = resolved() } def defer[A](fa: => Function0[A]): Function0[A] = { lazy val cachedFa = fa @@ -65,15 +67,17 @@ private[instances] trait FunctionInstancesBinCompat0 { implicit def catsStdDeferForFunction1[A]: Defer[A => *] = new Defer[A => *] { case class Deferred[B](fa: () => A => B) extends (A => B) { - def apply(a: A) = { + private lazy val resolved: A => B = { @annotation.tailrec - def loop(f: () => A => B): B = + def loop(f: () => A => B): A => B = f() match { case Deferred(f) => loop(f) - case next => next(a) + case next => next } + loop(fa) } + def apply(a: A): B = resolved(a) } def defer[B](fa: => A => B): A => B = { lazy val cachedFa = fa diff --git a/core/src/main/scala/cats/instances/hash.scala b/core/src/main/scala/cats/instances/hash.scala index 4e97a194ce..9175d0dd4f 100644 --- a/core/src/main/scala/cats/instances/hash.scala +++ b/core/src/main/scala/cats/instances/hash.scala @@ -22,6 +22,8 @@ package cats package instances +import scala.annotation.tailrec + trait HashInstances extends kernel.instances.HashInstances { implicit val catsContravariantForHash: Contravariant[Hash] = @@ -34,4 +36,34 @@ trait HashInstances extends kernel.instances.HashInstances { } + implicit def catsDeferForHash: Defer[Hash] = HashInstances.catsDeferForHashCache +} +object HashInstances { + private val catsDeferForHashCache: Defer[Hash] = + new Defer[Hash] { + case class Deferred[A](fa: () => Hash[A]) extends Hash[A] { + private lazy val resolve: Hash[A] = { + @tailrec + def loop(f: () => Hash[A]): Hash[A] = + f() match { + case Deferred(f) => loop(f) + case next => next + } + + loop(fa) + } + + override def hash(x: A): Int = resolve.hash(x) + + /** + * Returns `true` if `x` and `y` are equivalent, `false` otherwise. + */ + override def eqv(x: A, y: A): Boolean = resolve.eqv(x, y) + } + + override def defer[A](fa: => Hash[A]): Hash[A] = { + lazy val cachedFa = fa + Deferred(() => cachedFa) + } + } } diff --git a/core/src/main/scala/cats/instances/order.scala b/core/src/main/scala/cats/instances/order.scala index 66db216969..c1b4eab29b 100644 --- a/core/src/main/scala/cats/instances/order.scala +++ b/core/src/main/scala/cats/instances/order.scala @@ -24,6 +24,8 @@ package instances import cats.kernel.instances.unit._ +import scala.annotation.tailrec + trait OrderInstances extends kernel.instances.OrderInstances { implicit val catsContravariantMonoidalForOrder: ContravariantMonoidal[Order] = @@ -47,4 +49,29 @@ trait OrderInstances extends kernel.instances.OrderInstances { if (z == 0) fb.compare(x._2, y._2) else z } } + + implicit def catsDeferForOrder: Defer[Order] = OrderInstances.catsDeferForOrderCache +} +object OrderInstances { + private val catsDeferForOrderCache: Defer[Order] = + new Defer[Order] { + case class Deferred[A](fa: () => Order[A]) extends Order[A] { + private lazy val resolved: Order[A] = { + @tailrec + def loop(f: () => Order[A]): Order[A] = + f() match { + case Deferred(f) => loop(f) + case next => next + } + + loop(fa) + } + override def compare(x: A, y: A): Int = resolved.compare(x, y) + } + + override def defer[A](fa: => Order[A]): Order[A] = { + lazy val cachedFa = fa + Deferred(() => cachedFa) + } + } } diff --git a/core/src/main/scala/cats/instances/ordering.scala b/core/src/main/scala/cats/instances/ordering.scala index f900232102..802e778e20 100644 --- a/core/src/main/scala/cats/instances/ordering.scala +++ b/core/src/main/scala/cats/instances/ordering.scala @@ -24,6 +24,8 @@ package instances import cats.kernel.instances.unit._ +import scala.annotation.tailrec + trait OrderingInstances { implicit val catsContravariantMonoidalForOrdering: ContravariantMonoidal[Ordering] = new ContravariantMonoidal[Ordering] { @@ -43,4 +45,29 @@ trait OrderingInstances { } } } + + implicit def catsStdDeferForOrdering: Defer[Ordering] = OrderingInstances.catsStdDeferForOrderingCache +} +object OrderingInstances { + private val catsStdDeferForOrderingCache: Defer[Ordering] = + new Defer[Ordering] { + case class Deferred[A](fa: () => Ordering[A]) extends Ordering[A] { + private lazy val resolved: Ordering[A] = { + @tailrec + def loop(f: () => Ordering[A]): Ordering[A] = + f() match { + case Deferred(f) => loop(f) + case next => next + } + + loop(fa) + } + override def compare(x: A, y: A): Int = resolved.compare(x, y) + } + + override def defer[A](fa: => Ordering[A]): Ordering[A] = { + lazy val cachedFa = fa + Deferred(() => cachedFa) + } + } } diff --git a/core/src/main/scala/cats/instances/partialOrder.scala b/core/src/main/scala/cats/instances/partialOrder.scala index 4464897841..81bdce03e1 100644 --- a/core/src/main/scala/cats/instances/partialOrder.scala +++ b/core/src/main/scala/cats/instances/partialOrder.scala @@ -23,6 +23,8 @@ package cats package instances import cats.kernel.instances.unit._ +import scala.annotation.tailrec + trait PartialOrderInstances extends kernel.instances.PartialOrderInstances { implicit val catsContravariantMonoidalForPartialOrder: ContravariantMonoidal[PartialOrder] = new ContravariantMonoidal[PartialOrder] { @@ -41,4 +43,29 @@ trait PartialOrderInstances extends kernel.instances.PartialOrderInstances { def unit: PartialOrder[Unit] = Order[Unit] } + + implicit def catsDeferForPartialOrder: Defer[PartialOrder] = PartialOrderInstances.catsDeferForPartialOrderCache +} +object PartialOrderInstances { + private val catsDeferForPartialOrderCache: Defer[PartialOrder] = + new Defer[PartialOrder] { + case class Deferred[A](fa: () => PartialOrder[A]) extends PartialOrder[A] { + private lazy val resolved: PartialOrder[A] = { + @tailrec + def loop(f: () => PartialOrder[A]): PartialOrder[A] = + f() match { + case Deferred(f) => loop(f) + case next => next + } + + loop(fa) + } + override def partialCompare(x: A, y: A): Double = resolved.partialCompare(x, y) + } + + override def defer[A](fa: => PartialOrder[A]): PartialOrder[A] = { + lazy val cachedFa = fa + Deferred(() => cachedFa) + } + } } diff --git a/core/src/main/scala/cats/instances/partialOrdering.scala b/core/src/main/scala/cats/instances/partialOrdering.scala index 0830000e77..586c9492dd 100644 --- a/core/src/main/scala/cats/instances/partialOrdering.scala +++ b/core/src/main/scala/cats/instances/partialOrdering.scala @@ -22,6 +22,8 @@ package cats package instances +import scala.annotation.tailrec + trait PartialOrderingInstances { implicit val catsContravariantMonoidalForPartialOrdering: ContravariantMonoidal[PartialOrdering] = new ContravariantMonoidal[PartialOrdering] { @@ -50,4 +52,33 @@ trait PartialOrderingInstances { def unit: PartialOrdering[Unit] = cats.instances.unit.catsKernelStdOrderForUnit.toOrdering } + + implicit def catsStdDeferForPartialOrdering: Defer[PartialOrdering] = + PartialOrderingInstances.catsStdDeferForPartialOrderingCache +} +object PartialOrderingInstances { + private val catsStdDeferForPartialOrderingCache: Defer[PartialOrdering] = + new Defer[PartialOrdering] { + case class Deferred[A](fa: () => PartialOrdering[A]) extends PartialOrdering[A] { + private lazy val resolve: PartialOrdering[A] = { + @tailrec + def loop(f: () => PartialOrdering[A]): PartialOrdering[A] = + f() match { + case Deferred(f) => loop(f) + case next => next + } + + loop(fa) + } + + override def tryCompare(x: A, y: A): Option[Int] = resolve.tryCompare(x, y) + + override def lteq(x: A, y: A): Boolean = resolve.lteq(x, y) + } + + override def defer[A](fa: => PartialOrdering[A]): PartialOrdering[A] = { + lazy val cachedFa = fa + Deferred(() => cachedFa) + } + } } diff --git a/core/src/main/scala/cats/instances/show.scala b/core/src/main/scala/cats/instances/show.scala new file mode 100644 index 0000000000..2f2c01907a --- /dev/null +++ b/core/src/main/scala/cats/instances/show.scala @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2015 Typelevel + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + * the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +package cats +package instances + +import scala.annotation.tailrec + +trait ShowInstances { + implicit def catsDeferForShow: Defer[Show] = ShowInstances.catsDeferForShowCache +} +object ShowInstances { + private val catsDeferForShowCache: Defer[Show] = + new Defer[Show] { + case class Deferred[A](fa: () => Show[A]) extends Show[A] { + private lazy val resolved: Show[A] = { + @tailrec + def loop(f: () => Show[A]): Show[A] = + f() match { + case Deferred(f) => loop(f) + case next => next + } + + loop(fa) + } + override def show(t: A): String = resolved.show(t) + } + + override def defer[A](fa: => Show[A]): Show[A] = { + lazy val cachedFa = fa + Deferred(() => cachedFa) + } + } +} diff --git a/tests/shared/src/test/scala/cats/tests/EqSuite.scala b/tests/shared/src/test/scala/cats/tests/EqSuite.scala index f832faf99d..a08fa60e96 100644 --- a/tests/shared/src/test/scala/cats/tests/EqSuite.scala +++ b/tests/shared/src/test/scala/cats/tests/EqSuite.scala @@ -24,7 +24,7 @@ package cats.tests import cats.{Contravariant, ContravariantMonoidal, ContravariantSemigroupal, Invariant, Semigroupal} import cats.kernel.Eq import cats.kernel.laws.discipline.SerializableTests -import cats.laws.discipline.{ContravariantMonoidalTests, MiniInt} +import cats.laws.discipline.{ContravariantMonoidalTests, DeferTests, MiniInt} import cats.laws.discipline.arbitrary._ import cats.laws.discipline.eq._ @@ -36,5 +36,5 @@ class EqSuite extends CatsSuite { checkAll("Eq", ContravariantMonoidalTests[Eq].contravariantMonoidal[MiniInt, Boolean, Boolean]) checkAll("ContravariantMonoidal[Eq]", SerializableTests.serializable(ContravariantMonoidal[Eq])) - + checkAll("Defer[Eq]", DeferTests[Eq].defer[MiniInt]) } diff --git a/tests/shared/src/test/scala/cats/tests/EquivSuite.scala b/tests/shared/src/test/scala/cats/tests/EquivSuite.scala index 9c0d75eb71..b4de6aaaa8 100644 --- a/tests/shared/src/test/scala/cats/tests/EquivSuite.scala +++ b/tests/shared/src/test/scala/cats/tests/EquivSuite.scala @@ -40,4 +40,5 @@ class EquivSuite extends CatsSuite { ContravariantMonoidalTests[Equiv].contravariantMonoidal[MiniInt, Boolean, Boolean] ) checkAll("ContravariantMonoidal[Equiv]", SerializableTests.serializable(ContravariantMonoidal[Equiv])) + checkAll("Defer[Equiv]", DeferTests[Equiv].defer[MiniInt]) } diff --git a/tests/shared/src/test/scala/cats/tests/HashSuite.scala b/tests/shared/src/test/scala/cats/tests/HashSuite.scala index 4879f320fb..c81d78f069 100644 --- a/tests/shared/src/test/scala/cats/tests/HashSuite.scala +++ b/tests/shared/src/test/scala/cats/tests/HashSuite.scala @@ -23,6 +23,9 @@ package cats.tests import cats.{Contravariant, Invariant} import cats.kernel.Hash +import cats.laws.discipline.{DeferTests, MiniInt} +import cats.laws.discipline.arbitrary._ +import cats.laws.discipline.eq._ import cats.syntax.hash._ class HashSuite extends CatsSuite { @@ -34,5 +37,5 @@ class HashSuite extends CatsSuite { assert(1.hash == 1.hashCode) assert("ABC".hash == "ABC".hashCode) - + checkAll("Defer[Hash]", DeferTests[Hash].defer[MiniInt]) } diff --git a/tests/shared/src/test/scala/cats/tests/OrderSuite.scala b/tests/shared/src/test/scala/cats/tests/OrderSuite.scala index 8dbd6745e9..ec093bea93 100644 --- a/tests/shared/src/test/scala/cats/tests/OrderSuite.scala +++ b/tests/shared/src/test/scala/cats/tests/OrderSuite.scala @@ -24,7 +24,7 @@ package cats.tests import cats.{Contravariant, ContravariantMonoidal, Invariant} import cats.kernel.{Order, PartialOrder} import cats.kernel.laws.discipline.{OrderTests, SerializableTests} -import cats.laws.discipline.{ContravariantMonoidalTests, MiniInt} +import cats.laws.discipline.{ContravariantMonoidalTests, DeferTests, MiniInt} import cats.laws.discipline.arbitrary._ import cats.laws.discipline.eq._ import cats.tests.Helpers.Ord @@ -45,6 +45,7 @@ class OrderSuite extends CatsSuite { checkAll("Order", ContravariantMonoidalTests[Order].contravariantMonoidal[MiniInt, Boolean, Boolean]) checkAll("ContravariantMonoidal[Order]", SerializableTests.serializable(ContravariantMonoidal[Order])) + checkAll("Defer[Order]", DeferTests[Order].defer[MiniInt]) test("order ops syntax") { forAll { (i: Ord, j: Ord) => diff --git a/tests/shared/src/test/scala/cats/tests/OrderingSuite.scala b/tests/shared/src/test/scala/cats/tests/OrderingSuite.scala index 1eb478c4ac..b06b5d7dd3 100644 --- a/tests/shared/src/test/scala/cats/tests/OrderingSuite.scala +++ b/tests/shared/src/test/scala/cats/tests/OrderingSuite.scala @@ -40,4 +40,5 @@ class OrderingSuite extends CatsSuite { ContravariantMonoidalTests[Ordering].contravariantMonoidal[MiniInt, Boolean, Boolean] ) checkAll("ContravariantMonoidal[Ordering]", SerializableTests.serializable(ContravariantMonoidal[Ordering])) + checkAll("Defer[Ordering]", DeferTests[Ordering].defer[MiniInt]) } diff --git a/tests/shared/src/test/scala/cats/tests/PartialOrderSuite.scala b/tests/shared/src/test/scala/cats/tests/PartialOrderSuite.scala index 19cd765def..5fffe1c874 100644 --- a/tests/shared/src/test/scala/cats/tests/PartialOrderSuite.scala +++ b/tests/shared/src/test/scala/cats/tests/PartialOrderSuite.scala @@ -24,7 +24,7 @@ package cats.tests import cats.{Contravariant, ContravariantMonoidal, Invariant} import cats.kernel.{Order, PartialOrder} import cats.kernel.laws.discipline.SerializableTests -import cats.laws.discipline.{ContravariantMonoidalTests, MiniInt} +import cats.laws.discipline.{ContravariantMonoidalTests, DeferTests, MiniInt} import cats.laws.discipline.arbitrary._ import cats.laws.discipline.eq._ import cats.syntax.all._ @@ -47,6 +47,7 @@ class PartialOrderSuite extends CatsSuite { checkAll("PartialOrder", ContravariantMonoidalTests[PartialOrder].contravariantMonoidal[MiniInt, Boolean, Boolean]) checkAll("ContravariantMonoidal[PartialOrder]", SerializableTests.serializable(ContravariantMonoidal[PartialOrder])) + checkAll("Defer[PartialOrder]", DeferTests[PartialOrder].defer[MiniInt]) test("companion object syntax") { forAll { (i: Int, j: Int) => diff --git a/tests/shared/src/test/scala/cats/tests/PartialOrderingSuite.scala b/tests/shared/src/test/scala/cats/tests/PartialOrderingSuite.scala index 03beb98e7a..7b302ee958 100644 --- a/tests/shared/src/test/scala/cats/tests/PartialOrderingSuite.scala +++ b/tests/shared/src/test/scala/cats/tests/PartialOrderingSuite.scala @@ -43,4 +43,5 @@ class PartialOrderingSuite extends CatsSuite { checkAll("ContravariantMonoidal[PartialOrdering]", SerializableTests.serializable(ContravariantMonoidal[PartialOrdering]) ) + checkAll("Defer[PartialOrdering]", DeferTests[PartialOrdering].defer[MiniInt]) } diff --git a/tests/shared/src/test/scala/cats/tests/ShowSuite.scala b/tests/shared/src/test/scala/cats/tests/ShowSuite.scala index 1ef5e413bd..e449a95613 100644 --- a/tests/shared/src/test/scala/cats/tests/ShowSuite.scala +++ b/tests/shared/src/test/scala/cats/tests/ShowSuite.scala @@ -25,9 +25,10 @@ import cats.{Contravariant, Show} import cats.Show.ContravariantShow import cats.kernel.Order import cats.syntax.show._ -import cats.laws.discipline.{ContravariantTests, MiniInt, SerializableTests} +import cats.laws.discipline.{ContravariantTests, DeferTests, MiniInt, SerializableTests} import cats.laws.discipline.arbitrary._ import cats.laws.discipline.eq._ + import java.util.concurrent.TimeUnit import scala.collection.immutable.Seq import scala.concurrent.duration.{Duration, FiniteDuration} @@ -35,6 +36,7 @@ import scala.concurrent.duration.{Duration, FiniteDuration} class ShowSuite extends CatsSuite { checkAll("Contravariant[Show]", ContravariantTests[Show].contravariant[MiniInt, Int, Boolean]) checkAll("Contravariant[Show]", SerializableTests.serializable(Contravariant[Show])) + checkAll("Defer[Show]", DeferTests[Show].defer[MiniInt]) sealed trait TimeOfDay case object Morning extends TimeOfDay