Fix warnings with Scala 3.9

core/src/main/scala-2.13+/cats/data/NonEmptyLazyList.scala

@@ -375,7 +375,7 @@ class NonEmptyLazyListOps[A](private val value: NonEmptyLazyList[A])
    */
   final def sortBy[B](f: A => B)(implicit B: Order[B]): NonEmptyLazyList[A] =
     // safe: sorting a NonEmptyList cannot produce an empty List
-    create(toLazyList.sortBy(f)(B.toOrdering))
+    create(toLazyList.sortBy(f)(using B.toOrdering))
 
   /**
    * Sorts this `NonEmptyList` according to an `Order`
@@ -389,7 +389,7 @@ class NonEmptyLazyListOps[A](private val value: NonEmptyLazyList[A])
    * }}}
    */
   final def sorted[AA >: A](implicit AA: Order[AA]): NonEmptyLazyList[AA] =
-    create(toLazyList.sorted(AA.toOrdering))
+    create(toLazyList.sorted(using AA.toOrdering))
 
   /**
    * Groups elements inside this `NonEmptyLazyList` according to the `Order`
@@ -564,7 +564,7 @@ sealed abstract private[data] class NonEmptyLazyListInstances extends NonEmptyLa
       type F[x] = OneAnd[ZipLazyList, x]
 
       def applicative: Applicative[OneAnd[ZipLazyList, *]] =
-        OneAnd.catsDataApplicativeForOneAnd(ZipLazyList.catsDataAlternativeForZipLazyList)
+        OneAnd.catsDataApplicativeForOneAnd(using ZipLazyList.catsDataAlternativeForZipLazyList)
       def monad: Monad[NonEmptyLazyList] = NonEmptyLazyList.catsDataInstancesForNonEmptyLazyList
 
       def sequential: OneAnd[ZipLazyList, *] ~> NonEmptyLazyList =

core/src/main/scala-2.13+/cats/data/OneAndLowPriority4.scala

@@ -43,7 +43,7 @@ abstract private[data] class OneAndLowPriority4 {
         fa.head
 
       def map[A, B](fa: OneAnd[Stream, A])(f: A => B): OneAnd[Stream, B] =
-        fa.map(f)(cats.instances.stream.catsStdInstancesForStream)
+        fa.map(f)(using cats.instances.stream.catsStdInstancesForStream)
     }
 
   implicit val catsDataComonadForNonEmptyLazyList: Comonad[OneAnd[LazyList, *]] =
@@ -62,6 +62,6 @@ abstract private[data] class OneAndLowPriority4 {
         fa.head
 
       def map[A, B](fa: OneAnd[LazyList, A])(f: A => B): OneAnd[LazyList, B] =
-        fa.map(f)(cats.instances.lazyList.catsStdInstancesForLazyList)
+        fa.map(f)(using cats.instances.lazyList.catsStdInstancesForLazyList)
     }
 }

core/src/main/scala-2.13+/cats/data/ZipLazyList.scala

@@ -48,5 +48,5 @@ object ZipLazyList {
     }
 
   implicit def catsDataEqForZipLazyList[A: Eq]: Eq[ZipLazyList[A]] =
-    Eq.by((_: ZipLazyList[A]).value)(cats.kernel.instances.lazyList.catsKernelStdEqForLazyList[A])
+    Eq.by((_: ZipLazyList[A]).value)(using cats.kernel.instances.lazyList.catsKernelStdEqForLazyList[A])
 }

core/src/main/scala-2.13+/cats/data/ZipStream.scala

@@ -50,5 +50,5 @@ object ZipStream {
     }
 
   implicit def catsDataEqForZipStream[A: Eq]: Eq[ZipStream[A]] =
-    Eq.by((_: ZipStream[A]).value)(cats.kernel.instances.stream.catsKernelStdEqForStream[A])
+    Eq.by((_: ZipStream[A]).value)(using cats.kernel.instances.stream.catsKernelStdEqForStream[A])
 }

core/src/main/scala-2.13+/cats/instances/arraySeq.scala

@@ -106,15 +106,15 @@ private[cats] object ArraySeqInstances {
       def traverse[G[_], A, B](fa: ArraySeq[A])(f: A => G[B])(implicit G: Applicative[G]): G[ArraySeq[B]] =
         G match {
           case x: StackSafeMonad[G] =>
-            x.map(Traverse.traverseDirectly(fa.iterator)(f)(x))(_.iterator.to(ArraySeq.untagged))
+            x.map(Traverse.traverseDirectly(fa.iterator)(f)(using x))(_.iterator.to(ArraySeq.untagged))
           case _ =>
             G.map(Chain.traverseViaChain(fa)(f))(_.iterator.to(ArraySeq.untagged))
 
         }
 
       override def traverseVoid[G[_], A, B](fa: ArraySeq[A])(f: A => G[B])(implicit G: Applicative[G]): G[Unit] =
         G match {
-          case x: StackSafeMonad[G] => Traverse.traverseVoidDirectly(fa)(f)(x)
+          case x: StackSafeMonad[G] => Traverse.traverseVoidDirectly(fa)(f)(using x)
           case _                    =>
             foldRight(fa, Eval.now(G.unit)) { (a, acc) =>
               G.map2Eval(f(a), acc) { (_, _) =>
@@ -124,7 +124,7 @@ private[cats] object ArraySeqInstances {
         }
 
       override def mapAccumulate[S, A, B](init: S, fa: ArraySeq[A])(f: (S, A) => (S, B)): (S, ArraySeq[B]) =
-        StaticMethods.mapAccumulateFromStrictFunctor(init, fa, f)(this)
+        StaticMethods.mapAccumulateFromStrictFunctor(init, fa, f)(using this)
 
       override def mapWithIndex[A, B](fa: ArraySeq[A])(f: (A, Int) => B): ArraySeq[B] =
         ArraySeq.untagged.tabulate(n = fa.length) { i =>
@@ -235,7 +235,7 @@ private[cats] object ArraySeqInstances {
       )(f: (A) => G[Option[B]])(implicit G: Applicative[G]): G[ArraySeq[B]] =
         G match {
           case x: StackSafeMonad[G] =>
-            x.map(TraverseFilter.traverseFilterDirectly(fa.iterator)(f)(x))(
+            x.map(TraverseFilter.traverseFilterDirectly(fa.iterator)(f)(using x))(
               _.iterator.to(ArraySeq.untagged)
             )
           case _ =>

core/src/main/scala/cats/Alternative.scala

@@ -49,7 +49,7 @@ trait Alternative[F[_]] extends NonEmptyAlternative[F] with MonoidK[F] { self =>
    * }}}
    */
   def unite[G[_], A](fga: F[G[A]])(implicit FM: FlatMap[F], G: Foldable[G]): F[A] =
-    FM.flatMap(fga) { G.foldMapK(_)(pure)(self) }
+    FM.flatMap(fga) { G.foldMapK(_)(pure)(using self) }
 
   // Note: `protected` is only necessary to enforce binary compatibility
   // since neither `private` nor `private[cats]` work properly here.
@@ -71,8 +71,8 @@ trait Alternative[F[_]] extends NonEmptyAlternative[F] with MonoidK[F] { self =>
    * }}}
    */
   def separate[G[_, _], A, B](fgab: F[G[A, B]])(implicit FM: FlatMap[F], G: Bifoldable[G]): (F[A], F[B]) = {
-    val as = FM.flatMap(fgab)(gab => G.bifoldMap(gab)(pure, _ => empty[A])(algebra[A]))
-    val bs = FM.flatMap(fgab)(gab => G.bifoldMap(gab)(_ => empty[B], pure)(algebra[B]))
+    val as = FM.flatMap(fgab)(gab => G.bifoldMap(gab)(pure, _ => empty[A])(using algebra[A]))
+    val bs = FM.flatMap(fgab)(gab => G.bifoldMap(gab)(_ => empty[B], pure)(using algebra[B]))
     (as, bs)
   }
 
@@ -157,7 +157,7 @@ object Alternative {
       // Note: edited manually since seems Simulacrum is not able to handle the bin-compat redirection properly.
       typeClassInstance.separate[G, B, C](self.asInstanceOf[F[G[B, C]]])
     def separateFoldable[G[_, _], B, C](implicit ev$1: A <:< G[B, C], G: Bifoldable[G], FF: Foldable[F]): (F[B], F[C]) =
-      typeClassInstance.separateFoldable[G, B, C](self.asInstanceOf[F[G[B, C]]])(G, FF)
+      typeClassInstance.separateFoldable[G, B, C](self.asInstanceOf[F[G[B, C]]])(using G, FF)
   }
   trait AllOps[F[_], A] extends Ops[F, A] with NonEmptyAlternative.AllOps[F, A] with MonoidK.AllOps[F, A] {
     type TypeClassType <: Alternative[F]

core/src/main/scala/cats/Bifoldable.scala

@@ -132,8 +132,8 @@ object Bifoldable extends cats.instances.NTupleBitraverseInstances {
     def bifoldRight[C](c: Eval[C])(f: (A, Eval[C]) => Eval[C], g: (B, Eval[C]) => Eval[C]): Eval[C] =
       typeClassInstance.bifoldRight[A, B, C](self, c)(f, g)
     def bifoldMap[C](f: A => C, g: B => C)(implicit C: Monoid[C]): C =
-      typeClassInstance.bifoldMap[A, B, C](self)(f, g)(C)
-    def bifold(implicit A: Monoid[A], B: Monoid[B]): (A, B) = typeClassInstance.bifold[A, B](self)(A, B)
+      typeClassInstance.bifoldMap[A, B, C](self)(f, g)(using C)
+    def bifold(implicit A: Monoid[A], B: Monoid[B]): (A, B) = typeClassInstance.bifold[A, B](self)(using A, B)
   }
   trait AllOps[F[_, _], A, B] extends Ops[F, A, B]
   trait ToBifoldableOps extends Serializable {

core/src/main/scala/cats/ContravariantSemigroupal.scala

@@ -83,5 +83,5 @@ object ContravariantSemigroupal extends SemigroupalArityFunctions {
 
 private[cats] class ContravariantSemigroupalSemigroup[F[_], A](f: ContravariantSemigroupal[F]) extends Semigroup[F[A]] {
   def combine(a: F[A], b: F[A]): F[A] =
-    ContravariantSemigroupal.contramap2(a, b)((a: A) => (a, a))(f, f)
+    ContravariantSemigroupal.contramap2(a, b)((a: A) => (a, a))(using f, f)
 }

core/src/main/scala/cats/Foldable.scala

@@ -122,7 +122,7 @@ trait Foldable[F[_]] extends UnorderedFoldable[F] with FoldableNFunctions[F] { s
         case None            => gb
       }
     }
-    Defer[G].defer(loop(Source.fromFoldable(fa)(self)))
+    Defer[G].defer(loop(Source.fromFoldable(fa)(using self)))
   }
 
   def reduceLeftToOption[A, B](fa: F[A])(f: A => B)(g: (B, A) => B): Option[B] =
@@ -132,7 +132,7 @@ trait Foldable[F[_]] extends UnorderedFoldable[F] with FoldableNFunctions[F] { s
     }
 
   def reduceRightToOption[A, B](fa: F[A])(f: A => B)(g: (A, Eval[B]) => Eval[B]): Eval[Option[B]] = {
-    Source.fromFoldable(fa)(self).uncons match {
+    Source.fromFoldable(fa)(using self).uncons match {
       case Some((first, s)) =>
         def loop(now: A, source: Source[A]): Eval[B] =
           source.uncons match {
@@ -241,7 +241,7 @@ trait Foldable[F[_]] extends UnorderedFoldable[F] with FoldableNFunctions[F] { s
    * @see [[maximumByOption]] for maximum instead of minimum.
    */
   def minimumByOption[A, B: Order](fa: F[A])(f: A => B): Option[A] =
-    minimumOption(fa)(Order.by(f))
+    minimumOption(fa)(using Order.by(f))
 
   /**
    * Find the maximum `A` item in this structure according to an `Order.by(f)`.
@@ -255,7 +255,7 @@ trait Foldable[F[_]] extends UnorderedFoldable[F] with FoldableNFunctions[F] { s
    * @see [[minimumByOption]] for minimum instead of maximum.
    */
   def maximumByOption[A, B: Order](fa: F[A])(f: A => B): Option[A] =
-    maximumOption(fa)(Order.by(f))
+    maximumOption(fa)(using Order.by(f))
 
   /**
    * Find all the minimum `A` items in this structure.
@@ -299,7 +299,7 @@ trait Foldable[F[_]] extends UnorderedFoldable[F] with FoldableNFunctions[F] { s
    * @see [[maximumByList]] for maximum instead of minimum.
    */
   def minimumByList[A, B: Order](fa: F[A])(f: A => B): List[A] =
-    minimumList(fa)(Order.by(f))
+    minimumList(fa)(using Order.by(f))
 
   /**
    * Find all the maximum `A` items in this structure according to an `Order.by(f)`.
@@ -311,7 +311,7 @@ trait Foldable[F[_]] extends UnorderedFoldable[F] with FoldableNFunctions[F] { s
    * @see [[minimumByList]] for minimum instead of maximum.
    */
   def maximumByList[A, B: Order](fa: F[A])(f: A => B): List[A] =
-    maximumList(fa)(Order.by(f))
+    maximumList(fa)(using Order.by(f))
 
   def sumAll[A](fa: F[A])(implicit A: Numeric[A]): A =
     foldLeft(fa, A.zero)(A.plus)
@@ -390,7 +390,7 @@ trait Foldable[F[_]] extends UnorderedFoldable[F] with FoldableNFunctions[F] { s
    */
 
   def collectFirstSomeM[G[_], A, B](fa: F[A])(f: A => G[Option[B]])(implicit G: Monad[G]): G[Option[B]] =
-    G.tailRecM(Foldable.Source.fromFoldable(fa)(self))(_.uncons match {
+    G.tailRecM(Foldable.Source.fromFoldable(fa)(using self))(_.uncons match {
       case Some((a, src)) =>
         G.map(f(a)) {
           case None => Left(src.value)
@@ -474,7 +474,7 @@ trait Foldable[F[_]] extends UnorderedFoldable[F] with FoldableNFunctions[F] { s
    * in terms of `foldRight`.
    */
   def foldM[G[_], A, B](fa: F[A], z: B)(f: (B, A) => G[B])(implicit G: Monad[G]): G[B] = {
-    val src = Foldable.Source.fromFoldable(fa)(self)
+    val src = Foldable.Source.fromFoldable(fa)(using self)
     G.tailRecM((z, src)) { case (b, src) =>
       src.uncons match {
         case Some((a, src)) => G.map(f(b, a))(b => Left((b, src.value)))
@@ -647,7 +647,7 @@ trait Foldable[F[_]] extends UnorderedFoldable[F] with FoldableNFunctions[F] { s
    * }}}
    */
   def foldK[G[_], A](fga: F[G[A]])(implicit G: MonoidK[G]): G[A] =
-    fold(fga)(G.algebra)
+    fold(fga)(using G.algebra)
 
   /**
    * Find the first element matching the predicate, if one exists.
@@ -680,7 +680,7 @@ trait Foldable[F[_]] extends UnorderedFoldable[F] with FoldableNFunctions[F] { s
    */
 
   def findM[G[_], A](fa: F[A])(p: A => G[Boolean])(implicit G: Monad[G]): G[Option[A]] =
-    G.tailRecM(Foldable.Source.fromFoldable(fa)(self))(_.uncons match {
+    G.tailRecM(Foldable.Source.fromFoldable(fa)(using self))(_.uncons match {
       case Some((a, src)) => G.map(p(a))(if (_) Right(Some(a)) else Left(src.value))
       case None           => G.pure(Right(None))
     })
@@ -729,7 +729,7 @@ trait Foldable[F[_]] extends UnorderedFoldable[F] with FoldableNFunctions[F] { s
    * }}}
    */
   def existsM[G[_], A](fa: F[A])(p: A => G[Boolean])(implicit G: Monad[G]): G[Boolean] =
-    G.tailRecM(Foldable.Source.fromFoldable(fa)(self)) { src =>
+    G.tailRecM(Foldable.Source.fromFoldable(fa)(using self)) { src =>
       src.uncons match {
         case Some((a, src)) => G.map(p(a))(bb => if (bb) Right(true) else Left(src.value))
         case None           => G.pure(Right(false))
@@ -764,7 +764,7 @@ trait Foldable[F[_]] extends UnorderedFoldable[F] with FoldableNFunctions[F] { s
    * }}}
    */
   def forallM[G[_], A](fa: F[A])(p: A => G[Boolean])(implicit G: Monad[G]): G[Boolean] =
-    G.tailRecM(Foldable.Source.fromFoldable(fa)(self)) { src =>
+    G.tailRecM(Foldable.Source.fromFoldable(fa)(using self)) { src =>
       src.uncons match {
         case Some((a, src)) => G.map(p(a))(bb => if (!bb) Right(false) else Left(src.value))
         case None           => G.pure(Right(true))
@@ -853,7 +853,7 @@ trait Foldable[F[_]] extends UnorderedFoldable[F] with FoldableNFunctions[F] { s
    * }}}
    */
   def intercalate[A](fa: F[A], a: A)(implicit A: Monoid[A]): A =
-    combineAllOption(fa)(A.intercalate(a)) match {
+    combineAllOption(fa)(using A.intercalate(a)) match {
       case None    => A.empty
       case Some(a) => a
     }
@@ -958,7 +958,7 @@ trait Foldable[F[_]] extends UnorderedFoldable[F] with FoldableNFunctions[F] { s
     fa: F[A]
   )(f: A => G[Either[B, C]])(implicit A: Alternative[F], M: Monad[G]): G[(F[B], F[C])] = {
     import cats.instances.either.*
-    partitionBifoldM[G, Either, A, B, C](fa)(f)(A, M, Bifoldable[Either])
+    partitionBifoldM[G, Either, A, B, C](fa)(f)(using A, M, Bifoldable[Either])
   }
 }
 
@@ -1041,38 +1041,38 @@ object Foldable {
       typeClassInstance.reduceRightToOption[A, B](self)(f)(g)
     def reduceLeftOption(f: (A, A) => A): Option[A] = typeClassInstance.reduceLeftOption[A](self)(f)
     def reduceRightOption(f: (A, Eval[A]) => Eval[A]): Eval[Option[A]] = typeClassInstance.reduceRightOption[A](self)(f)
-    def minimumOption(implicit A: Order[A]): Option[A] = typeClassInstance.minimumOption[A](self)(A)
-    def maximumOption(implicit A: Order[A]): Option[A] = typeClassInstance.maximumOption[A](self)(A)
+    def minimumOption(implicit A: Order[A]): Option[A] = typeClassInstance.minimumOption[A](self)(using A)
+    def maximumOption(implicit A: Order[A]): Option[A] = typeClassInstance.maximumOption[A](self)(using A)
     def minimumByOption[B](f: A => B)(implicit ev$1: Order[B]): Option[A] =
       typeClassInstance.minimumByOption[A, B](self)(f)
     def maximumByOption[B](f: A => B)(implicit ev$1: Order[B]): Option[A] =
       typeClassInstance.maximumByOption[A, B](self)(f)
-    def minimumList(implicit A: Order[A]): List[A] = typeClassInstance.minimumList[A](self)(A)
-    def maximumList(implicit A: Order[A]): List[A] = typeClassInstance.maximumList[A](self)(A)
+    def minimumList(implicit A: Order[A]): List[A] = typeClassInstance.minimumList[A](self)(using A)
+    def maximumList(implicit A: Order[A]): List[A] = typeClassInstance.maximumList[A](self)(using A)
     def minimumByList[B](f: A => B)(implicit ev$1: Order[B]): List[A] = typeClassInstance.minimumByList[A, B](self)(f)
     def maximumByList[B](f: A => B)(implicit ev$1: Order[B]): List[A] = typeClassInstance.maximumByList[A, B](self)(f)
     def get(idx: Long): Option[A] = typeClassInstance.get[A](self)(idx)
     def collectFirst[B](pf: PartialFunction[A, B]): Option[B] = typeClassInstance.collectFirst[A, B](self)(pf)
     def collectFirstSome[B](f: A => Option[B]): Option[B] = typeClassInstance.collectFirstSome[A, B](self)(f)
     def collectFoldSome[B](f: A => Option[B])(implicit B: Monoid[B]): B =
-      typeClassInstance.collectFoldSome[A, B](self)(f)(B)
-    def fold(implicit A: Monoid[A]): A = typeClassInstance.fold[A](self)(A)
+      typeClassInstance.collectFoldSome[A, B](self)(f)(using B)
+    def fold(implicit A: Monoid[A]): A = typeClassInstance.fold[A](self)(using A)
     def sumAll(implicit A: Numeric[A]): A = typeClassInstance.sumAll[A](self)
     def productAll(implicit A: Numeric[A]): A = typeClassInstance.productAll[A](self)
     def combineAll(implicit ev$1: Monoid[A]): A = typeClassInstance.combineAll[A](self)
-    def combineAllOption(implicit ev: Semigroup[A]): Option[A] = typeClassInstance.combineAllOption[A](self)(ev)
+    def combineAllOption(implicit ev: Semigroup[A]): Option[A] = typeClassInstance.combineAllOption[A](self)(using ev)
     def toIterable: Iterable[A] = typeClassInstance.toIterable[A](self)
-    def foldMap[B](f: A => B)(implicit B: Monoid[B]): B = typeClassInstance.foldMap[A, B](self)(f)(B)
+    def foldMap[B](f: A => B)(implicit B: Monoid[B]): B = typeClassInstance.foldMap[A, B](self)(f)(using B)
     def foldM[G[_], B](z: B)(f: (B, A) => G[B])(implicit G: Monad[G]): G[B] =
-      typeClassInstance.foldM[G, A, B](self, z)(f)(G)
+      typeClassInstance.foldM[G, A, B](self, z)(f)(using G)
     final def foldLeftM[G[_], B](z: B)(f: (B, A) => G[B])(implicit G: Monad[G]): G[B] =
-      typeClassInstance.foldLeftM[G, A, B](self, z)(f)(G)
+      typeClassInstance.foldLeftM[G, A, B](self, z)(f)(using G)
     def foldMapM[G[_], B](f: A => G[B])(implicit G: Monad[G], B: Monoid[B]): G[B] =
-      typeClassInstance.foldMapM[G, A, B](self)(f)(G, B)
+      typeClassInstance.foldMapM[G, A, B](self)(f)(using G, B)
     def foldMapA[G[_], B](f: A => G[B])(implicit G: Applicative[G], B: Monoid[B]): G[B] =
-      typeClassInstance.foldMapA[G, A, B](self)(f)(G, B)
+      typeClassInstance.foldMapA[G, A, B](self)(f)(using G, B)
     def traverseVoid[G[_], B](f: A => G[B])(implicit G: Applicative[G]): G[Unit] =
-      typeClassInstance.traverseVoid[G, A, B](self)(f)(G)
+      typeClassInstance.traverseVoid[G, A, B](self)(f)(using G)
     def traverse_[G[_], B](f: A => G[B])(implicit G: Applicative[G]): G[Unit] =
       traverseVoid[G, B](f)
     // TODO: looks like these two methods below duplicate the same named methods from `NestedFoldableOps`.
@@ -1083,19 +1083,19 @@ object Foldable {
     def sequence_[G[_], B](implicit ev$1: A <:< G[B], ev$2: Applicative[G]): G[Unit] =
       sequenceVoid[G, B]
     def foldK[G[_], B](implicit ev$1: A <:< G[B], G: MonoidK[G]): G[B] =
-      typeClassInstance.foldK[G, B](self.asInstanceOf[F[G[B]]])(G)
+      typeClassInstance.foldK[G, B](self.asInstanceOf[F[G[B]]])(using G)
     def find(f: A => Boolean): Option[A] = typeClassInstance.find[A](self)(f)
     def existsM[G[_]](p: A => G[Boolean])(implicit G: Monad[G]): G[Boolean] =
-      typeClassInstance.existsM[G, A](self)(p)(G)
+      typeClassInstance.existsM[G, A](self)(p)(using G)
     def forallM[G[_]](p: A => G[Boolean])(implicit G: Monad[G]): G[Boolean] =
-      typeClassInstance.forallM[G, A](self)(p)(G)
+      typeClassInstance.forallM[G, A](self)(p)(using G)
     def toList: List[A] = typeClassInstance.toList[A](self)
     def partitionEither[B, C](f: A => Either[B, C])(implicit A: Alternative[F]): (F[B], F[C]) =
-      typeClassInstance.partitionEither[A, B, C](self)(f)(A)
+      typeClassInstance.partitionEither[A, B, C](self)(f)(using A)
     def filter_(p: A => Boolean): List[A] = typeClassInstance.filter_[A](self)(p)
     def takeWhile_(p: A => Boolean): List[A] = typeClassInstance.takeWhile_[A](self)(p)
     def dropWhile_(p: A => Boolean): List[A] = typeClassInstance.dropWhile_[A](self)(p)
-    def intercalate(a: A)(implicit A: Monoid[A]): A = typeClassInstance.intercalate[A](self, a)(A)
+    def intercalate(a: A)(implicit A: Monoid[A]): A = typeClassInstance.intercalate[A](self, a)(using A)
   }
   trait AllOps[F[_], A] extends Ops[F, A] with UnorderedFoldable.AllOps[F, A] {
     type TypeClassType <: Foldable[F]

core/src/main/scala/cats/Invariant.scala

@@ -166,7 +166,7 @@ object Invariant extends ScalaVersionSpecificInvariantInstances with InvariantIn
   implicit def catsInstancesForFuture(implicit
     ec: ExecutionContext
   ): MonadThrow[Future] & CoflatMap[Future] =
-    cats.instances.future.catsStdInstancesForFuture(ec)
+    cats.instances.future.catsStdInstancesForFuture(using ec)
 
   implicit def catsContravariantMonoidalForOrder: ContravariantMonoidal[Order] =
     cats.instances.order.catsContravariantMonoidalForOrder

core/src/main/scala/cats/InvariantSemigroupal.scala

@@ -87,5 +87,5 @@ object InvariantSemigroupal extends SemigroupalArityFunctions {
 private[cats] class InvariantSemigroupalSemigroup[F[_], A](f: InvariantSemigroupal[F], sg: Semigroup[A])
     extends Semigroup[F[A]] {
   def combine(a: F[A], b: F[A]): F[A] =
-    InvariantSemigroupal.imap2(a, b)(sg.combine)(a => (a, a))(f, f)
+    InvariantSemigroupal.imap2(a, b)(sg.combine)(a => (a, a))(using f, f)
 }