From bffd62344de2d6b512975c5919ce1c52590302d3 Mon Sep 17 00:00:00 2001 From: xuwei-k <6b656e6a69@gmail.com> Date: Wed, 9 Sep 2026 09:11:48 +0900 Subject: [PATCH] Fix Deferred warnings --- core/src/main/scala/cats/instances/eq.scala | 28 +++++++-------- .../src/main/scala/cats/instances/equiv.scala | 28 +++++++-------- core/src/main/scala/cats/instances/hash.scala | 36 +++++++++---------- .../src/main/scala/cats/instances/order.scala | 28 +++++++-------- .../main/scala/cats/instances/ordering.scala | 28 +++++++-------- .../scala/cats/instances/partialOrder.scala | 28 +++++++-------- .../cats/instances/partialOrdering.scala | 30 ++++++++-------- core/src/main/scala/cats/instances/show.scala | 28 +++++++-------- 8 files changed, 117 insertions(+), 117 deletions(-) diff --git a/core/src/main/scala/cats/instances/eq.scala b/core/src/main/scala/cats/instances/eq.scala index 5c96a8c219..ba82d9a619 100644 --- a/core/src/main/scala/cats/instances/eq.scala +++ b/core/src/main/scala/cats/instances/eq.scala @@ -49,22 +49,22 @@ trait EqInstances extends kernel.instances.EqInstances { 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) + final private 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 } - override def eqv(x: A, y: A): Boolean = resolved.eqv(x, y) - } + loop(fa) + } + override def eqv(x: A, y: A): Boolean = resolved.eqv(x, y) + } + + private val catsDeferForEqCache: Defer[Eq] = + new Defer[Eq] { 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 941fd6e911..df61f37b7b 100644 --- a/core/src/main/scala/cats/instances/equiv.scala +++ b/core/src/main/scala/cats/instances/equiv.scala @@ -58,22 +58,22 @@ trait EquivInstances { 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) + final private 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 } - override def equiv(x: A, y: A): Boolean = resolved.equiv(x, y) - } + loop(fa) + } + override def equiv(x: A, y: A): Boolean = resolved.equiv(x, y) + } + + private val catsDeferForEquivCache: Defer[Equiv] = + new Defer[Equiv] { override def defer[A](fa: => Equiv[A]): Equiv[A] = { lazy val cachedFa = fa Deferred(() => cachedFa) diff --git a/core/src/main/scala/cats/instances/hash.scala b/core/src/main/scala/cats/instances/hash.scala index 9175d0dd4f..a38c6d341b 100644 --- a/core/src/main/scala/cats/instances/hash.scala +++ b/core/src/main/scala/cats/instances/hash.scala @@ -39,28 +39,28 @@ 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) + final private 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 } - override def hash(x: A): Int = resolve.hash(x) + 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) - } + /** + * Returns `true` if `x` and `y` are equivalent, `false` otherwise. + */ + override def eqv(x: A, y: A): Boolean = resolve.eqv(x, y) + } + private val catsDeferForHashCache: Defer[Hash] = + new Defer[Hash] { 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 88f2e08956..3d054c780a 100644 --- a/core/src/main/scala/cats/instances/order.scala +++ b/core/src/main/scala/cats/instances/order.scala @@ -53,22 +53,22 @@ trait OrderInstances extends kernel.instances.OrderInstances { 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) + final private 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 } - override def compare(x: A, y: A): Int = resolved.compare(x, y) - } + loop(fa) + } + override def compare(x: A, y: A): Int = resolved.compare(x, y) + } + + private val catsDeferForOrderCache: Defer[Order] = + new Defer[Order] { 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 08b5697f07..c0f5fe4903 100644 --- a/core/src/main/scala/cats/instances/ordering.scala +++ b/core/src/main/scala/cats/instances/ordering.scala @@ -49,22 +49,22 @@ 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) + final private 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 } - override def compare(x: A, y: A): Int = resolved.compare(x, y) - } + loop(fa) + } + override def compare(x: A, y: A): Int = resolved.compare(x, y) + } + + private val catsStdDeferForOrderingCache: Defer[Ordering] = + new Defer[Ordering] { 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 dee8ae942c..55c7b03a28 100644 --- a/core/src/main/scala/cats/instances/partialOrder.scala +++ b/core/src/main/scala/cats/instances/partialOrder.scala @@ -47,22 +47,22 @@ trait PartialOrderInstances extends kernel.instances.PartialOrderInstances { 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) + final private 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 } - override def partialCompare(x: A, y: A): Double = resolved.partialCompare(x, y) - } + loop(fa) + } + override def partialCompare(x: A, y: A): Double = resolved.partialCompare(x, y) + } + + private val catsDeferForPartialOrderCache: Defer[PartialOrder] = + new Defer[PartialOrder] { 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 586c9492dd..517fff8086 100644 --- a/core/src/main/scala/cats/instances/partialOrdering.scala +++ b/core/src/main/scala/cats/instances/partialOrdering.scala @@ -57,25 +57,25 @@ trait PartialOrderingInstances { 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) + final private 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 } - override def tryCompare(x: A, y: A): Option[Int] = resolve.tryCompare(x, y) + loop(fa) + } - override def lteq(x: A, y: A): Boolean = resolve.lteq(x, y) - } + 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) + } + private val catsStdDeferForPartialOrderingCache: Defer[PartialOrdering] = + new Defer[PartialOrdering] { 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 index 2f2c01907a..173f14b013 100644 --- a/core/src/main/scala/cats/instances/show.scala +++ b/core/src/main/scala/cats/instances/show.scala @@ -28,22 +28,22 @@ 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) + final private 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 } - override def show(t: A): String = resolved.show(t) - } + loop(fa) + } + override def show(t: A): String = resolved.show(t) + } + + private val catsDeferForShowCache: Defer[Show] = + new Defer[Show] { override def defer[A](fa: => Show[A]): Show[A] = { lazy val cachedFa = fa Deferred(() => cachedFa)