Avoid dollars in param names

core/src/main/scala/cats/Align.scala

@@ -182,7 +182,8 @@ object Align extends ScalaVersionSpecificAlignInstances {
     val typeClassInstance: TypeClassType
     def align[B](fb: F[B]): F[Ior[A, B]] = typeClassInstance.align[A, B](self, fb)
     def alignWith[B, C](fb: F[B])(f: Ior[A, B] => C): F[C] = typeClassInstance.alignWith[A, B, C](self, fb)(f)
-    def alignCombine(fa2: F[A])(implicit ev$1: Semigroup[A]): F[A] = typeClassInstance.alignCombine[A](self, fa2)
+    def alignCombine(fa2: F[A])(implicit @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: Semigroup[A]): F[A] =
+      typeClassInstance.alignCombine[A](self, fa2)
     def alignMergeWith(fa2: F[A])(f: (A, A) => A): F[A] = typeClassInstance.alignMergeWith[A](self, fa2)(f)
     def padZip[B](fb: F[B]): F[(Option[A], Option[B])] = typeClassInstance.padZip[A, B](self, fb)
     def padZipWith[B, C](fb: F[B])(f: (Option[A], Option[B]) => C): F[C] =

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

@@ -150,13 +150,25 @@ object Alternative {
     type TypeClassType <: Alternative[F]
     def self: F[A]
     val typeClassInstance: TypeClassType
-    def unite[G[_], B](implicit ev$1: A <:< G[B], FM: Monad[F], G: Foldable[G]): F[B] =
+    def unite[G[_], B](implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: A <:< G[B],
+      FM: Monad[F],
+      G: Foldable[G]
+    ): F[B] =
       // Note: edited manually since seems Simulacrum is not able to handle the bin-compat redirection properly.
       typeClassInstance.unite[G, B](self.asInstanceOf[F[G[B]]])
-    def separate[G[_, _], B, C](implicit ev$1: A <:< G[B, C], FM: Monad[F], G: Bifoldable[G]): (F[B], F[C]) =
+    def separate[G[_, _], B, C](implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: A <:< G[B, C],
+      FM: Monad[F],
+      G: Bifoldable[G]
+    ): (F[B], F[C]) =
       // 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]) =
+    def separateFoldable[G[_, _], B, C](implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: 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)
   }
   trait AllOps[F[_], A] extends Ops[F, A] with NonEmptyAlternative.AllOps[F, A] with MonoidK.AllOps[F, A] {

core/src/main/scala/cats/Apply.scala

@@ -286,15 +286,19 @@ object Apply {
     type TypeClassType <: Apply[F]
     def self: F[A]
     val typeClassInstance: TypeClassType
-    def ap[B, C](fa: F[B])(implicit ev$1: A <:< (B => C)): F[C] =
+    def ap[B, C](fa: F[B])(implicit @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: A <:< (B => C)): F[C] =
       typeClassInstance.ap[B, C](self.asInstanceOf[F[B => C]])(fa)
     def productR[B](fb: F[B]): F[B] = typeClassInstance.productR[A, B](self)(fb)
     def productL[B](fb: F[B]): F[A] = typeClassInstance.productL[A, B](self)(fb)
-    @inline final def <*>[B, C](fa: F[B])(implicit ev$1: A <:< (B => C)): F[C] =
+    @inline final def <*>[B, C](fa: F[B])(implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: A <:< (B => C)
+    ): F[C] =
       typeClassInstance.<*>[B, C](self.asInstanceOf[F[B => C]])(fa)
     @inline final def *>[B](fb: F[B]): F[B] = typeClassInstance.*>[A, B](self)(fb)
     @inline final def <*[B](fb: F[B]): F[A] = typeClassInstance.<*[A, B](self)(fb)
-    def ap2[B, C, D](fa: F[B], fb: F[C])(implicit ev$1: A <:< ((B, C) => D)): F[D] =
+    def ap2[B, C, D](fa: F[B], fb: F[C])(implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: A <:< ((B, C) => D)
+    ): F[D] =
       typeClassInstance.ap2[B, C, D](self.asInstanceOf[F[(B, C) => D]])(fa, fb)
     def map2[B, C](fb: F[B])(f: (A, B) => C): F[C] = typeClassInstance.map2[A, B, C](self, fb)(f)
     def map2Eval[B, C](fb: Eval[F[B]])(f: (A, B) => C): Eval[F[C]] = typeClassInstance.map2Eval[A, B, C](self, fb)(f)

core/src/main/scala/cats/Bitraverse.scala

@@ -152,9 +152,15 @@ object Bitraverse {
     type TypeClassType <: Bitraverse[F]
     def self: F[A, B]
     val typeClassInstance: TypeClassType
-    def bitraverse[G[_], C, D](f: A => G[C], g: B => G[D])(implicit ev$1: Applicative[G]): G[F[C, D]] =
+    def bitraverse[G[_], C, D](f: A => G[C], g: B => G[D])(implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: Applicative[G]
+    ): G[F[C, D]] =
       typeClassInstance.bitraverse[G, A, B, C, D](self)(f, g)
-    def bisequence[G[_], C, D](implicit ev$1: A <:< G[C], ev$2: B <:< G[D], ev$3: Applicative[G]): G[F[C, D]] =
+    def bisequence[G[_], C, D](implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: A <:< G[C],
+      @deprecatedName(Symbol("ev$2"), "2.14.0") ev2: B <:< G[D],
+      @deprecatedName(Symbol("ev$3"), "2.14.0") ev3: Applicative[G]
+    ): G[F[C, D]] =
       typeClassInstance.bisequence[G, C, D](self.asInstanceOf[F[G[C], G[D]]])
   }
   trait AllOps[F[_, _], A, B] extends Ops[F, A, B] with Bifoldable.AllOps[F, A, B] with Bifunctor.AllOps[F, A, B] {

core/src/main/scala/cats/FlatMap.scala

@@ -246,7 +246,8 @@ object FlatMap {
     def self: F[A]
     val typeClassInstance: TypeClassType
     def flatMap[B](f: A => F[B]): F[B] = typeClassInstance.flatMap[A, B](self)(f)
-    def flatten[B](implicit ev$1: A <:< F[B]): F[B] = typeClassInstance.flatten[B](self.asInstanceOf[F[F[B]]])
+    def flatten[B](implicit @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: A <:< F[B]): F[B] =
+      typeClassInstance.flatten[B](self.asInstanceOf[F[F[B]]])
     def productREval[B](fb: Eval[F[B]]): F[B] = typeClassInstance.productREval[A, B](self)(fb)
     def productLEval[B](fb: Eval[F[B]]): F[A] = typeClassInstance.productLEval[A, B](self)(fb)
     def mproduct[B](f: A => F[B]): F[(A, B)] = typeClassInstance.mproduct[A, B](self)(f)

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

@@ -1033,7 +1033,9 @@ object Foldable {
     val typeClassInstance: TypeClassType
     def foldLeft[B](b: B)(f: (B, A) => B): B = typeClassInstance.foldLeft[A, B](self, b)(f)
     def foldRight[B](lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B] = typeClassInstance.foldRight[A, B](self, lb)(f)
-    def foldRightDefer[G[_], B](gb: G[B])(fn: (A, G[B]) => G[B])(implicit ev$1: Defer[G]): G[B] =
+    def foldRightDefer[G[_], B](gb: G[B])(fn: (A, G[B]) => G[B])(implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: Defer[G]
+    ): G[B] =
       typeClassInstance.foldRightDefer[G, A, B](self, gb)(fn)
     def reduceLeftToOption[B](f: A => B)(g: (B, A) => B): Option[B] =
       typeClassInstance.reduceLeftToOption[A, B](self)(f)(g)
@@ -1043,14 +1045,16 @@ object Foldable {
     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 minimumByOption[B](f: A => B)(implicit ev$1: Order[B]): Option[A] =
+    def minimumByOption[B](f: A => B)(implicit @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: Order[B]): Option[A] =
       typeClassInstance.minimumByOption[A, B](self)(f)
-    def maximumByOption[B](f: A => B)(implicit ev$1: Order[B]): Option[A] =
+    def maximumByOption[B](f: A => B)(implicit @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: 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 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 minimumByList[B](f: A => B)(implicit @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: Order[B]): List[A] =
+      typeClassInstance.minimumByList[A, B](self)(f)
+    def maximumByList[B](f: A => B)(implicit @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: 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)
@@ -1059,7 +1063,8 @@ object Foldable {
     def fold(implicit A: Monoid[A]): A = typeClassInstance.fold[A](self)(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 combineAll(implicit @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: Monoid[A]): A =
+      typeClassInstance.combineAll[A](self)
     def combineAllOption(implicit ev: Semigroup[A]): Option[A] = typeClassInstance.combineAllOption[A](self)(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)
@@ -1078,11 +1083,17 @@ object Foldable {
     // TODO: looks like these two methods below duplicate the same named methods from `NestedFoldableOps`.
     //       Moreover, the other two methods take precedence, thereby these two are not in use whatsoever.
     //       Perhaps it makes sense to deprecate one pair of them either here or there.
-    def sequenceVoid[G[_], B](implicit ev$1: A <:< G[B], ev$2: Applicative[G]): G[Unit] =
+    def sequenceVoid[G[_], B](implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: A <:< G[B],
+      @deprecatedName(Symbol("ev$2"), "2.14.0") ev2: Applicative[G]
+    ): G[Unit] =
       typeClassInstance.sequenceVoid[G, B](self.asInstanceOf[F[G[B]]])
-    def sequence_[G[_], B](implicit ev$1: A <:< G[B], ev$2: Applicative[G]): G[Unit] =
+    def sequence_[G[_], B](implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: A <:< G[B],
+      @deprecatedName(Symbol("ev$2"), "2.14.0") ev2: Applicative[G]
+    ): G[Unit] =
       sequenceVoid[G, B]
-    def foldK[G[_], B](implicit ev$1: A <:< G[B], G: MonoidK[G]): G[B] =
+    def foldK[G[_], B](implicit @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: A <:< G[B], G: MonoidK[G]): G[B] =
       typeClassInstance.foldK[G, B](self.asInstanceOf[F[G[B]]])(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] =

core/src/main/scala/cats/FunctorFilter.scala

@@ -131,7 +131,7 @@ object FunctorFilter extends ScalaVersionSpecificTraverseFilterInstances with Fu
     val typeClassInstance: TypeClassType
     def mapFilter[B](f: A => Option[B]): F[B] = typeClassInstance.mapFilter[A, B](self)(f)
     def collect[B](f: PartialFunction[A, B]): F[B] = typeClassInstance.collect[A, B](self)(f)
-    def flattenOption[B](implicit ev$1: A <:< Option[B]): F[B] =
+    def flattenOption[B](implicit @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: A <:< Option[B]): F[B] =
       typeClassInstance.flattenOption[B](self.asInstanceOf[F[Option[B]]])
     def filter(f: A => Boolean): F[A] = typeClassInstance.filter[A](self)(f)
     def filterNot(f: A => Boolean): F[A] = typeClassInstance.filterNot[A](self)(f)

core/src/main/scala/cats/NonEmptyTraverse.scala

@@ -135,13 +135,22 @@ object NonEmptyTraverse {
     type TypeClassType <: NonEmptyTraverse[F]
     def self: F[A]
     val typeClassInstance: TypeClassType
-    def nonEmptyTraverse[G[_], B](f: A => G[B])(implicit ev$1: Apply[G]): G[F[B]] =
+    def nonEmptyTraverse[G[_], B](f: A => G[B])(implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: Apply[G]
+    ): G[F[B]] =
       typeClassInstance.nonEmptyTraverse[G, A, B](self)(f)
-    def nonEmptySequence[G[_], B](implicit ev$1: A <:< G[B], ev$2: Apply[G]): G[F[B]] =
+    def nonEmptySequence[G[_], B](implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: A <:< G[B],
+      @deprecatedName(Symbol("ev$2"), "2.14.0") ev2: Apply[G]
+    ): G[F[B]] =
       typeClassInstance.nonEmptySequence[G, B](self.asInstanceOf[F[G[B]]])
     def nonEmptyFlatTraverse[G[_], B](f: A => G[F[B]])(implicit G: Apply[G], F: FlatMap[F]): G[F[B]] =
       typeClassInstance.nonEmptyFlatTraverse[G, A, B](self)(f)(G, F)
-    def nonEmptyFlatSequence[G[_], B](implicit ev$1: A <:< G[F[B]], G: Apply[G], F: FlatMap[F]): G[F[B]] =
+    def nonEmptyFlatSequence[G[_], B](implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: A <:< G[F[B]],
+      G: Apply[G],
+      F: FlatMap[F]
+    ): G[F[B]] =
       typeClassInstance.nonEmptyFlatSequence[G, B](self.asInstanceOf[F[G[F[B]]]])(G, F)
   }
   trait AllOps[F[_], A] extends Ops[F, A] with Traverse.AllOps[F, A] with Reducible.AllOps[F, A] {

core/src/main/scala/cats/Reducible.scala

@@ -402,7 +402,7 @@ object Reducible {
     def reduceLeft(f: (A, A) => A): A = typeClassInstance.reduceLeft[A](self)(f)
     def reduceRight(f: (A, Eval[A]) => Eval[A]): Eval[A] = typeClassInstance.reduceRight[A](self)(f)
     def reduce(implicit A: Semigroup[A]): A = typeClassInstance.reduce[A](self)(A)
-    def reduceK[G[_], B](implicit ev$1: A <:< G[B], G: SemigroupK[G]): G[B] =
+    def reduceK[G[_], B](implicit @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: A <:< G[B], G: SemigroupK[G]): G[B] =
       typeClassInstance.reduceK[G, B](self.asInstanceOf[F[G[B]]])(G)
     def reduceMap[B](f: A => B)(implicit B: Semigroup[B]): B = typeClassInstance.reduceMap[A, B](self)(f)(B)
     def reduceLeftTo[B](f: A => B)(g: (B, A) => B): B = typeClassInstance.reduceLeftTo[A, B](self)(f)(g)
@@ -418,20 +418,28 @@ object Reducible {
       typeClassInstance.nonEmptyTraverseVoid[G, A, B](self)(f)
     def nonEmptyTraverse_[G[_], B](f: A => G[B])(implicit G: Apply[G]): G[Unit] =
       nonEmptyTraverseVoid[G, B](f)
-    def nonEmptySequenceVoid[G[_], B](implicit ev$1: A <:< G[B], G: Apply[G]): G[Unit] =
+    def nonEmptySequenceVoid[G[_], B](implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: A <:< G[B],
+      G: Apply[G]
+    ): G[Unit] =
       typeClassInstance.nonEmptySequenceVoid[G, B](self.asInstanceOf[F[G[B]]])
-    def nonEmptySequence_[G[_], B](implicit ev$1: A <:< G[B], G: Apply[G]): G[Unit] =
+    def nonEmptySequence_[G[_], B](implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: A <:< G[B],
+      G: Apply[G]
+    ): G[Unit] =
       nonEmptySequenceVoid[G, B]
     def toNonEmptyList: NonEmptyList[A] = typeClassInstance.toNonEmptyList[A](self)
     def minimum(implicit A: Order[A]): A = typeClassInstance.minimum[A](self)(A)
     def maximum(implicit A: Order[A]): A = typeClassInstance.maximum[A](self)(A)
-    def minimumBy[B](f: A => B)(implicit ev$1: Order[B]): A = typeClassInstance.minimumBy[A, B](self)(f)
-    def maximumBy[B](f: A => B)(implicit ev$1: Order[B]): A = typeClassInstance.maximumBy[A, B](self)(f)
+    def minimumBy[B](f: A => B)(implicit @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: Order[B]): A =
+      typeClassInstance.minimumBy[A, B](self)(f)
+    def maximumBy[B](f: A => B)(implicit @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: Order[B]): A =
+      typeClassInstance.maximumBy[A, B](self)(f)
     def minimumNel(implicit A: Order[A]): NonEmptyList[A] = typeClassInstance.minimumNel[A](self)(A)
     def maximumNel(implicit A: Order[A]): NonEmptyList[A] = typeClassInstance.maximumNel[A](self)(A)
-    def minimumByNel[B](f: A => B)(implicit ev$1: Order[B]): NonEmptyList[A] =
+    def minimumByNel[B](f: A => B)(implicit @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: Order[B]): NonEmptyList[A] =
       typeClassInstance.minimumByNel[A, B](self)(f)
-    def maximumByNel[B](f: A => B)(implicit ev$1: Order[B]): NonEmptyList[A] =
+    def maximumByNel[B](f: A => B)(implicit @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: Order[B]): NonEmptyList[A] =
       typeClassInstance.maximumByNel[A, B](self)(f)
     def nonEmptyIntercalate(a: A)(implicit A: Semigroup[A]): A = typeClassInstance.nonEmptyIntercalate[A](self, a)(A)
     def nonEmptyPartition[B, C](f: A => Either[B, C]): Ior[NonEmptyList[B], NonEmptyList[C]] =

core/src/main/scala/cats/Traverse.scala

@@ -239,15 +239,26 @@ object Traverse {
     type TypeClassType <: Traverse[F]
     def self: F[A]
     val typeClassInstance: TypeClassType
-    def traverse[G[_], B](f: A => G[B])(implicit ev$1: Applicative[G]): G[F[B]] =
+    def traverse[G[_], B](f: A => G[B])(implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: Applicative[G]
+    ): G[F[B]] =
       typeClassInstance.traverse[G, A, B](self)(f)
-    def traverseTap[G[_], B](f: A => G[B])(implicit ev$1: Applicative[G]): G[F[A]] =
+    def traverseTap[G[_], B](f: A => G[B])(implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: Applicative[G]
+    ): G[F[A]] =
       typeClassInstance.traverseTap[G, A, B](self)(f)
     def flatTraverse[G[_], B](f: A => G[F[B]])(implicit G: Applicative[G], F: FlatMap[F]): G[F[B]] =
       typeClassInstance.flatTraverse[G, A, B](self)(f)(G, F)
-    def sequence[G[_], B](implicit ev$1: A <:< G[B], ev$2: Applicative[G]): G[F[B]] =
+    def sequence[G[_], B](implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: A <:< G[B],
+      @deprecatedName(Symbol("ev$2"), "2.14.0") ev2: Applicative[G]
+    ): G[F[B]] =
       typeClassInstance.sequence[G, B](self.asInstanceOf[F[G[B]]])
-    def flatSequence[G[_], B](implicit ev$1: A <:< G[F[B]], G: Applicative[G], F: FlatMap[F]): G[F[B]] =
+    def flatSequence[G[_], B](implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: A <:< G[F[B]],
+      G: Applicative[G],
+      F: FlatMap[F]
+    ): G[F[B]] =
       typeClassInstance.flatSequence[G, B](self.asInstanceOf[F[G[F[B]]]])(G, F)
     def mapAccumulate[S, B](init: S)(f: (S, A) => (S, B)): (S, F[B]) =
       typeClassInstance.mapAccumulate[S, A, B](init, self)(f)

core/src/main/scala/cats/UnorderedFoldable.scala

@@ -188,12 +188,18 @@ object UnorderedFoldable
     type TypeClassType <: UnorderedFoldable[F]
     def self: F[A]
     val typeClassInstance: TypeClassType
-    def unorderedFoldMap[B](f: A => B)(implicit ev$1: CommutativeMonoid[B]): B =
+    def unorderedFoldMap[B](f: A => B)(implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: CommutativeMonoid[B]
+    ): B =
       typeClassInstance.unorderedFoldMap[A, B](self)(f)
-    def unorderedFold(implicit ev$1: CommutativeMonoid[A]): A = typeClassInstance.unorderedFold[A](self)
+    def unorderedFold(implicit @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: CommutativeMonoid[A]): A =
+      typeClassInstance.unorderedFold[A](self)
     def unorderedFoldMapA[G[_], B](
       f: A => G[B]
-    )(implicit ev$1: CommutativeApplicative[G], ev$2: CommutativeMonoid[B]): G[B] =
+    )(implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: CommutativeApplicative[G],
+      @deprecatedName(Symbol("ev$2"), "2.14.0") ev2: CommutativeMonoid[B]
+    ): G[B] =
       typeClassInstance.unorderedFoldMapA[G, A, B](self)(f)
     def isEmpty: Boolean = typeClassInstance.isEmpty[A](self)
     def nonEmpty: Boolean = typeClassInstance.nonEmpty[A](self)

core/src/main/scala/cats/UnorderedTraverse.scala

@@ -53,9 +53,14 @@ object UnorderedTraverse {
     type TypeClassType <: UnorderedTraverse[F]
     def self: F[A]
     val typeClassInstance: TypeClassType
-    def unorderedTraverse[G[_], B](f: A => G[B])(implicit ev$1: CommutativeApplicative[G]): G[F[B]] =
+    def unorderedTraverse[G[_], B](f: A => G[B])(implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: CommutativeApplicative[G]
+    ): G[F[B]] =
       typeClassInstance.unorderedTraverse[G, A, B](self)(f)
-    def unorderedSequence[G[_], B](implicit ev$1: A <:< G[B], ev$2: CommutativeApplicative[G]): G[F[B]] =
+    def unorderedSequence[G[_], B](implicit
+      @deprecatedName(Symbol("ev$1"), "2.14.0") ev1: A <:< G[B],
+      @deprecatedName(Symbol("ev$2"), "2.14.0") ev2: CommutativeApplicative[G]
+    ): G[F[B]] =
       typeClassInstance.unorderedSequence[G, B](self.asInstanceOf[F[G[B]]])
   }
   trait AllOps[F[_], A] extends Ops[F, A] with UnorderedFoldable.AllOps[F, A] {