uniquify implicit names in syntax part 3 of #1061

core/src/main/scala/cats/syntax/applicative.scala

@@ -2,8 +2,8 @@ package cats
 package syntax
 
 trait ApplicativeSyntax {
-  implicit def applicativeIdSyntax[A](a: A): ApplicativeIdOps[A] = new ApplicativeIdOps[A](a)
-  implicit def applicativeEvalSyntax[A](a: Eval[A]): ApplicativeEvalOps[A] = new ApplicativeEvalOps[A](a)
+  implicit def catsSyntaxApplicativeId[A](a: A): ApplicativeIdOps[A] = new ApplicativeIdOps[A](a)
+  implicit def catsSyntaxApplicativeEval[A](a: Eval[A]): ApplicativeEvalOps[A] = new ApplicativeEvalOps[A](a)
 }
 
 final class ApplicativeIdOps[A](val a: A) extends AnyVal {

core/src/main/scala/cats/syntax/applicativeError.scala

@@ -4,10 +4,10 @@ package syntax
 import cats.data.{Xor, XorT}
 
 trait ApplicativeErrorSyntax {
-  implicit def applicativeErrorIdSyntax[E](e: E): ApplicativeErrorIdOps[E] =
+  implicit def catsSyntaxApplicativeErrorId[E](e: E): ApplicativeErrorIdOps[E] =
     new ApplicativeErrorIdOps(e)
 
-  implicit def applicativeErrorSyntax[F[_], E, A](fa: F[A])(implicit F: ApplicativeError[F, E]): ApplicativeErrorOps[F, E, A] =
+  implicit def catsSyntaxApplicativeError[F[_], E, A](fa: F[A])(implicit F: ApplicativeError[F, E]): ApplicativeErrorOps[F, E, A] =
     new ApplicativeErrorOps[F, E, A](fa)
 
 }

core/src/main/scala/cats/syntax/apply.scala

@@ -2,15 +2,15 @@ package cats
 package syntax
 
 trait ApplySyntax1 {
-  implicit def applySyntaxU[FA](fa: FA)(implicit U: Unapply[Apply, FA]): Apply.Ops[U.M, U.A] =
+  implicit def catsSyntaxUApply[FA](fa: FA)(implicit U: Unapply[Apply, FA]): Apply.Ops[U.M, U.A] =
     new Apply.Ops[U.M, U.A] {
       val self = U.subst(fa)
       val typeClassInstance = U.TC
     }
 }
 
 trait ApplySyntax extends ApplySyntax1 {
-  implicit def applySyntax[F[_], A](fa: F[A])(implicit F: Apply[F]): Apply.Ops[F, A] =
+  implicit def catsSyntaxApply[F[_], A](fa: F[A])(implicit F: Apply[F]): Apply.Ops[F, A] =
     new Apply.Ops[F,A] {
       val self = fa
       val typeClassInstance = F

core/src/main/scala/cats/syntax/bifoldable.scala

@@ -2,7 +2,7 @@ package cats
 package syntax
 
 trait BifoldableSyntax {
-  implicit def bifoldableSyntax[F[_, _]: Bifoldable, A, B](fab: F[A, B]): BifoldableOps[F, A, B] =
+  implicit def catsSyntaxBifoldable[F[_, _]: Bifoldable, A, B](fab: F[A, B]): BifoldableOps[F, A, B] =
     new BifoldableOps[F, A, B](fab)
 }
 

core/src/main/scala/cats/syntax/bifunctor.scala

@@ -5,7 +5,7 @@ import cats.functor.Bifunctor
 
 trait BifunctorSyntax {
   // TODO: use simulacrum instances eventually
-  implicit def bifunctorSyntax[F[_, _]: Bifunctor, A, B](fab: F[A, B]): BifunctorOps[F, A, B] =
+  implicit def catsSyntaxBifunctor[F[_, _]: Bifunctor, A, B](fab: F[A, B]): BifunctorOps[F, A, B] =
     new BifunctorOps[F, A, B](fab)
 }
 

core/src/main/scala/cats/syntax/bitraverse.scala

@@ -2,12 +2,12 @@ package cats
 package syntax
 
 trait BitraverseSyntax extends BitraverseSyntax1 {
-  implicit def bitraverseSyntax[F[_, _]: Bitraverse, A, B](fab: F[A, B]): BitraverseOps[F, A, B] =
+  implicit def catsSyntaxBitraverse[F[_, _]: Bitraverse, A, B](fab: F[A, B]): BitraverseOps[F, A, B] =
     new BitraverseOps[F, A, B](fab)
 }
 
 private[syntax] trait BitraverseSyntax1 {
-  implicit def nestedBitraverseSyntax[F[_, _]: Bitraverse, G[_], A, B](fgagb: F[G[A], G[B]]): NestedBitraverseOps[F, G, A, B] =
+  implicit def catsSyntaxNestedBitraverse[F[_, _]: Bitraverse, G[_], A, B](fgagb: F[G[A], G[B]]): NestedBitraverseOps[F, G, A, B] =
     new NestedBitraverseOps[F, G, A, B](fgagb)
 }
 

core/src/main/scala/cats/syntax/cartesian.scala

@@ -2,15 +2,15 @@ package cats
 package syntax
 
 trait CartesianSyntax1 {
-  implicit def cartesianSyntaxU[FA](fa: FA)(implicit U: Unapply[Cartesian, FA]): CartesianOps[U.M, U.A] =
+  implicit def catsSyntaxUCartesian[FA](fa: FA)(implicit U: Unapply[Cartesian, FA]): CartesianOps[U.M, U.A] =
     new CartesianOps[U.M, U.A] {
       val self = U.subst(fa)
       val typeClassInstance = U.TC
     }
 }
 
 trait CartesianSyntax extends CartesianSyntax1 {
-  implicit def cartesianSyntax[F[_], A](fa: F[A])(implicit F: Cartesian[F]): CartesianOps[F, A] =
+  implicit def catsSyntaxCartesian[F[_], A](fa: F[A])(implicit F: Cartesian[F]): CartesianOps[F, A] =
     new CartesianOps[F, A] {
       val self = fa
       val typeClassInstance = F

core/src/main/scala/cats/syntax/coflatMap.scala

@@ -2,7 +2,7 @@ package cats
 package syntax
 
 trait CoflatMapSyntax1 {
-  implicit def coflatMapSyntaxU[FA](fa: FA)(implicit U: Unapply[CoflatMap, FA]): CoflatMap.Ops[U.M, U.A] = new CoflatMap.Ops[U.M, U.A] {
+  implicit def catsSyntaxUCoflatMap[FA](fa: FA)(implicit U: Unapply[CoflatMap, FA]): CoflatMap.Ops[U.M, U.A] = new CoflatMap.Ops[U.M, U.A] {
     val self = U.subst(fa)
     val typeClassInstance = U.TC
   }

core/src/main/scala/cats/syntax/comonad.scala

@@ -2,7 +2,7 @@ package cats
 package syntax
 
 trait ComonadSyntax1 {
-  implicit def comonadSyntaxU[FA](fa: FA)(implicit U: Unapply[Comonad, FA]): Comonad.Ops[U.M, U.A] =
+  implicit def catsSyntaxUComonad[FA](fa: FA)(implicit U: Unapply[Comonad, FA]): Comonad.Ops[U.M, U.A] =
     new Comonad.Ops[U.M, U.A] {
       val self = U.subst(fa)
       val typeClassInstance = U.TC

core/src/main/scala/cats/syntax/compose.scala

@@ -5,7 +5,7 @@ import cats.arrow.Compose
 
 trait ComposeSyntax {
   // TODO: use simulacrum instances eventually
-  implicit def composeSyntax[F[_, _]: Compose, A, B](fab: F[A, B]): ComposeOps[F, A, B] =
+  implicit def catsSyntaxCompose[F[_, _]: Compose, A, B](fab: F[A, B]): ComposeOps[F, A, B] =
     new ComposeOps[F, A, B](fab)
 }
 

core/src/main/scala/cats/syntax/contravariant.scala

@@ -5,7 +5,7 @@ import cats.functor.Contravariant
 
 
 trait ContravariantSyntax1 {
-  implicit def contravariantSyntaxU[FA](fa: FA)(implicit U: Unapply[Contravariant, FA]): Contravariant.Ops[U.M, U.A] =
+  implicit def catsSyntaxUContravariant[FA](fa: FA)(implicit U: Unapply[Contravariant, FA]): Contravariant.Ops[U.M, U.A] =
     new Contravariant.Ops[U.M, U.A] {
       val self = U.subst(fa)
       val typeClassInstance = U.TC

core/src/main/scala/cats/syntax/coproduct.scala

@@ -4,7 +4,7 @@ package syntax
 import cats.data.Coproduct
 
 trait CoproductSyntax {
-  implicit def coproductSyntax[F[_], A](a: F[A]): CoproductOps[F, A] = new CoproductOps(a)
+  implicit def catsSyntaxCoproduct[F[_], A](a: F[A]): CoproductOps[F, A] = new CoproductOps(a)
 }
 
 final class CoproductOps[F[_], A](val fa: F[A]) extends AnyVal {

core/src/main/scala/cats/syntax/either.scala

@@ -4,7 +4,7 @@ package syntax
 import cats.data.Xor
 
 trait EitherSyntax {
-  implicit def eitherSyntax[A, B](eab: Either[A, B]): EitherOps[A, B] = new EitherOps(eab)
+  implicit def catsSyntaxEither[A, B](eab: Either[A, B]): EitherOps[A, B] = new EitherOps(eab)
 }
 
 final class EitherOps[A, B](val eab: Either[A, B]) extends AnyVal {

core/src/main/scala/cats/syntax/eq.scala

@@ -4,7 +4,7 @@ package syntax
 import cats.macros.Ops
 
 trait EqSyntax {
-  implicit def eqSyntax[A: Eq](a: A): EqOps[A] =
+  implicit def catsSyntaxEq[A: Eq](a: A): EqOps[A] =
     new EqOps[A](a)
 }
 

core/src/main/scala/cats/syntax/flatMap.scala

@@ -2,18 +2,18 @@ package cats
 package syntax
 
 trait FlatMapSyntax1 {
-  implicit def flatMapSyntaxU[FA](fa: FA)(implicit U: Unapply[FlatMap, FA]): FlatMapOps[U.M, U.A] =
+  implicit def catsSyntaxUFlatMap[FA](fa: FA)(implicit U: Unapply[FlatMap, FA]): FlatMapOps[U.M, U.A] =
     new FlatMapOps[U.M, U.A](U.subst(fa))(U.TC)
 }
 
 trait FlatMapSyntax extends FlatMapSyntax1 {
-  implicit def flatMapSyntax[F[_]: FlatMap, A](fa: F[A]): FlatMapOps[F, A] =
+  implicit def catsSyntaxFlatMap[F[_]: FlatMap, A](fa: F[A]): FlatMapOps[F, A] =
     new FlatMapOps(fa)
 
-  implicit def flattenSyntax[F[_]: FlatMap, A](ffa: F[F[A]]): FlattenOps[F, A] =
+  implicit def catsSyntaxFlatten[F[_]: FlatMap, A](ffa: F[F[A]]): FlattenOps[F, A] =
     new FlattenOps[F, A](ffa)
 
-  implicit def ifMSyntax[F[_]: FlatMap](fa: F[Boolean]): IfMOps[F] =
+  implicit def catsSyntaxIfM[F[_]: FlatMap](fa: F[Boolean]): IfMOps[F] =
     new IfMOps[F](fa)
 }
 

core/src/main/scala/cats/syntax/foldable.scala

@@ -2,15 +2,15 @@ package cats
 package syntax
 
 trait FoldableSyntax1 {
-  implicit def foldableSyntaxU[FA](fa: FA)(implicit U: Unapply[Foldable,FA]): Foldable.Ops[U.M, U.A] =
+  implicit def catsSyntaxUFoldable[FA](fa: FA)(implicit U: Unapply[Foldable,FA]): Foldable.Ops[U.M, U.A] =
     new Foldable.Ops[U.M, U.A] {
       val self = U.subst(fa)
       val typeClassInstance = U.TC
       }
 }
 
 trait FoldableSyntax extends Foldable.ToFoldableOps with FoldableSyntax1 {
-  implicit def nestedFoldableSyntax[F[_]: Foldable, G[_], A](fga: F[G[A]]): NestedFoldableOps[F, G, A] =
+  implicit def catsSyntaxNestedFoldable[F[_]: Foldable, G[_], A](fga: F[G[A]]): NestedFoldableOps[F, G, A] =
     new NestedFoldableOps[F, G, A](fga)
 }
 

core/src/main/scala/cats/syntax/functor.scala

@@ -2,7 +2,7 @@ package cats
 package syntax
 
 trait FunctorSyntax1 {
-  implicit def functorSyntaxU[FA](fa: FA)(implicit U: Unapply[Functor,FA]): Functor.Ops[U.M, U.A] =
+  implicit def catsSyntaxUFunctor[FA](fa: FA)(implicit U: Unapply[Functor,FA]): Functor.Ops[U.M, U.A] =
     new Functor.Ops[U.M, U.A]{
       val self = U.subst(fa)
       val typeClassInstance = U.TC

core/src/main/scala/cats/syntax/group.scala

@@ -5,7 +5,7 @@ import cats.macros.Ops
 
 trait GroupSyntax extends SemigroupSyntax {
   // TODO: use simulacrum instances eventually
-  implicit def groupSyntax[A: Group](a: A): GroupOps[A] =
+  implicit def catsSyntaxGroup[A: Group](a: A): GroupOps[A] =
     new GroupOps[A](a)
 }
 

core/src/main/scala/cats/syntax/invariant.scala

@@ -4,7 +4,7 @@ package syntax
 import cats.functor.Invariant
 
 trait InvariantSyntax1 {
-  implicit def invariantSyntaxU[FA](fa: FA)(implicit U: Unapply[Invariant, FA]): Invariant.Ops[U.M, U.A] =
+  implicit def catsSyntaxUInvariant[FA](fa: FA)(implicit U: Unapply[Invariant, FA]): Invariant.Ops[U.M, U.A] =
     new Invariant.Ops[U.M, U.A] {
       val self = U.subst(fa)
       val typeClassInstance = U.TC

core/src/main/scala/cats/syntax/list.scala

@@ -4,7 +4,7 @@ package syntax
 import cats.data.NonEmptyList
 
 trait ListSyntax {
-  implicit def listSyntax[A](la: List[A]): ListOps[A] = new ListOps(la)
+  implicit def catsSyntaxList[A](la: List[A]): ListOps[A] = new ListOps(la)
 }
 
 final class ListOps[A](val la: List[A]) extends AnyVal {

core/src/main/scala/cats/syntax/monadCombine.scala

@@ -3,10 +3,10 @@ package syntax
 
 trait MonadCombineSyntax {
   // TODO: use simulacrum instances eventually
-  implicit def monadCombineSyntax[F[_]: MonadCombine, G[_], A](fga: F[G[A]]): MonadCombineOps[F, G, A] =
+  implicit def catsSyntaxMonadCombine[F[_]: MonadCombine, G[_], A](fga: F[G[A]]): MonadCombineOps[F, G, A] =
     new MonadCombineOps[F, G, A](fga)
 
-  implicit def separateSyntax[F[_]: MonadCombine, G[_, _], A, B](fgab: F[G[A, B]]): SeparateOps[F, G, A, B] =
+  implicit def catsSyntaxMonadCombineSeparate[F[_]: MonadCombine, G[_, _], A, B](fgab: F[G[A, B]]): SeparateOps[F, G, A, B] =
     new SeparateOps[F, G, A, B](fgab)
 }
 

core/src/main/scala/cats/syntax/monadError.scala

@@ -3,7 +3,7 @@ package syntax
 
 trait MonadErrorSyntax {
 
-  implicit def monadErrorSyntax[F[_], E, A](fa: F[A])(implicit F: MonadError[F, E]): MonadErrorOps[F, E, A] =
+  implicit def catsSyntaxMonadError[F[_], E, A](fa: F[A])(implicit F: MonadError[F, E]): MonadErrorOps[F, E, A] =
     new MonadErrorOps(fa)
 
 }

core/src/main/scala/cats/syntax/monadFilter.scala

@@ -2,7 +2,7 @@ package cats
 package syntax
 
 trait MonadFilterSyntax1 {
-  implicit def monadFilterSyntaxU[FA](fa: FA)(implicit U: Unapply[MonadFilter,FA]): MonadFilter.Ops[U.M, U.A] =
+  implicit def catsSyntaxUMonadFilter[FA](fa: FA)(implicit U: Unapply[MonadFilter,FA]): MonadFilter.Ops[U.M, U.A] =
     new MonadFilter.Ops[U.M, U.A] {
       val self = U.subst(fa)
       val typeClassInstance = U.TC

core/src/main/scala/cats/syntax/option.scala

@@ -5,8 +5,8 @@ import cats.data.{ Xor, Validated, ValidatedNel }
 
 trait OptionSyntax {
   final def none[A]: Option[A] = Option.empty[A]
-  implicit final def optionIdSyntax[A](a: A): OptionIdOps[A] = new OptionIdOps(a)
-  implicit final def optionSyntax[A](oa: Option[A]): OptionOps[A] = new OptionOps(oa)
+  implicit final def catsSyntaxOptionId[A](a: A): OptionIdOps[A] = new OptionIdOps(a)
+  implicit final def catsSyntaxOption[A](oa: Option[A]): OptionOps[A] = new OptionOps(oa)
 }
 
 final class OptionIdOps[A](val a: A) extends AnyVal {

core/src/main/scala/cats/syntax/order.scala

@@ -4,7 +4,7 @@ package syntax
 import cats.macros.Ops
 
 trait OrderSyntax extends PartialOrderSyntax {
-  implicit def orderSyntax[A: Order](a: A): OrderOps[A] =
+  implicit def catsSyntaxOrder[A: Order](a: A): OrderOps[A] =
     new OrderOps[A](a)
 }
 

core/src/main/scala/cats/syntax/partialOrder.scala

@@ -4,7 +4,7 @@ package syntax
 import cats.macros.Ops
 
 trait PartialOrderSyntax extends EqSyntax {
-  implicit def partialOrderSyntax[A: PartialOrder](a: A): PartialOrderOps[A] =
+  implicit def catsSyntaxPartialOrder[A: PartialOrder](a: A): PartialOrderOps[A] =
     new PartialOrderOps[A](a)
 }
 

core/src/main/scala/cats/syntax/profunctor.scala

@@ -5,7 +5,7 @@ import cats.functor.Profunctor
 
 trait ProfunctorSyntax {
   // TODO: use simulacrum instances eventually
-  implicit def profunctorSyntax[F[_, _]: Profunctor, A, B](fab: F[A, B]): ProfunctorOps[F, A, B] =
+  implicit def catsSyntaxProfunctor[F[_, _]: Profunctor, A, B](fab: F[A, B]): ProfunctorOps[F, A, B] =
     new ProfunctorOps[F, A, B](fab)
 }
 

core/src/main/scala/cats/syntax/reducible.scala

@@ -2,15 +2,15 @@ package cats
 package syntax
 
 trait ReducibleSyntax1 {
-  implicit def reducibleSyntaxU[FA](fa: FA)(implicit U: Unapply[Reducible,FA]): Reducible.Ops[U.M, U.A] =
+  implicit def catsSyntaxUReducible[FA](fa: FA)(implicit U: Unapply[Reducible,FA]): Reducible.Ops[U.M, U.A] =
     new Reducible.Ops[U.M, U.A] {
       val self = U.subst(fa)
       val typeClassInstance = U.TC
     }
 }
 
 trait ReducibleSyntax extends Reducible.ToReducibleOps with ReducibleSyntax1 {
-  implicit def nestedReducibleSyntax[F[_]: Reducible, G[_], A](fga: F[G[A]]): NestedReducibleOps[F, G, A] =
+  implicit def catsSyntaxNestedReducible[F[_]: Reducible, G[_], A](fga: F[G[A]]): NestedReducibleOps[F, G, A] =
     new NestedReducibleOps[F, G, A](fga)
 }
 

core/src/main/scala/cats/syntax/semigroup.scala

@@ -5,7 +5,7 @@ import cats.macros.Ops
 
 trait SemigroupSyntax {
   // TODO: use simulacrum instances eventually
-  implicit def semigroupSyntax[A: Semigroup](a: A): SemigroupOps[A] =
+  implicit def catsSyntaxSemigroup[A: Semigroup](a: A): SemigroupOps[A] =
     new SemigroupOps[A](a)
 }
 

core/src/main/scala/cats/syntax/semigroupk.scala

@@ -3,7 +3,7 @@ package syntax
 
 trait SemigroupKSyntax1 {
   // TODO: use simulacrum instances eventually
-  implicit def semigroupSyntaxU[FA](fa: FA)(implicit U: Unapply[SemigroupK,FA]): SemigroupK.Ops[U.M, U.A] =
+  implicit def catsSyntaxUSemigroup[FA](fa: FA)(implicit U: Unapply[SemigroupK,FA]): SemigroupK.Ops[U.M, U.A] =
     new SemigroupK.Ops[U.M, U.A] {
       val self = U.subst(fa)
       val typeClassInstance = U.TC

core/src/main/scala/cats/syntax/split.scala

@@ -5,7 +5,7 @@ import cats.arrow.Split
 
 trait SplitSyntax {
   // TODO: use simulacrum instances eventually
-  implicit def splitSyntax[F[_, _]: Split, A, B](fab: F[A, B]): SplitOps[F, A, B] =
+  implicit def catsSyntaxSplit[F[_, _]: Split, A, B](fab: F[A, B]): SplitOps[F, A, B] =
     new SplitOps[F, A, B](fab)
 }
 

core/src/main/scala/cats/syntax/strong.scala

@@ -5,7 +5,7 @@ import cats.functor.Strong
 
 trait StrongSyntax {
   // TODO: use simulacrum instances eventually
-  implicit def strongSyntax[F[_, _]: Strong, A, B](fab: F[A, B]): StrongOps[F, A, B] =
+  implicit def catsSyntaxStrong[F[_, _]: Strong, A, B](fab: F[A, B]): StrongOps[F, A, B] =
     new StrongOps[F, A, B](fab)
 }
 

core/src/main/scala/cats/syntax/transLift.scala

@@ -2,7 +2,7 @@ package cats
 package syntax
 
 trait TransLiftSyntax {
-  implicit def transLiftSyntax[E](ma: E)(implicit U: Unapply[Trivial.PH1, E]): TransLiftOps[U.M, U.A] = new TransLiftOps(U.subst(ma))
+  implicit def catsSyntaxTransLift[E](ma: E)(implicit U: Unapply[Trivial.PH1, E]): TransLiftOps[U.M, U.A] = new TransLiftOps(U.subst(ma))
 }
 
 final class TransLiftOps[M0[_], A](val ma: M0[A]) extends AnyVal {

core/src/main/scala/cats/syntax/traverse.scala

@@ -2,16 +2,16 @@ package cats
 package syntax
 
 trait TraverseSyntax1 {
-  implicit def traverseSyntaxU[FA](fa: FA)(implicit U: Unapply[Traverse,FA]): TraverseOps[U.M, U.A] =
+  implicit def catsSyntaxUTraverse[FA](fa: FA)(implicit U: Unapply[Traverse,FA]): TraverseOps[U.M, U.A] =
     new TraverseOps(U.subst(fa))(U.TC)
 }
 
 trait TraverseSyntax extends TraverseSyntax1 {
   // TODO: use simulacrum instances eventually
-  implicit def traverseSyntax[F[_]: Traverse, A](fa: F[A]): TraverseOps[F, A] =
+  implicit def catsSyntaxTraverse[F[_]: Traverse, A](fa: F[A]): TraverseOps[F, A] =
     new TraverseOps(fa)
 
-  implicit def nestedTraverseSyntax[F[_]: Traverse, G[_], A](fga: F[G[A]]): NestedTraverseOps[F, G, A] =
+  implicit def catsSyntaxNestedTraverse[F[_]: Traverse, G[_], A](fga: F[G[A]]): NestedTraverseOps[F, G, A] =
     new NestedTraverseOps[F, G, A](fga)
 }
 

core/src/main/scala/cats/syntax/validated.scala

@@ -4,7 +4,7 @@ package syntax
 import cats.data.{ Validated, ValidatedNel }
 
 trait ValidatedSyntax {
-  implicit def validatedIdSyntax[A](a: A): ValidatedIdSyntax[A] = new ValidatedIdSyntax(a)
+  implicit def catsSyntaxValidatedId[A](a: A): ValidatedIdSyntax[A] = new ValidatedIdSyntax(a)
 }
 
 final class ValidatedIdSyntax[A](val a: A) extends AnyVal {