From 23e325390b9cf9218c186cd7f2a41b5a49dafdae Mon Sep 17 00:00:00 2001 From: Kailuo Wang Date: Fri, 27 May 2016 10:43:35 -0400 Subject: [PATCH] renamed implicit vals in std part 2 of #1061 --- core/src/main/scala/cats/data/Cokleisli.scala | 12 ++-- core/src/main/scala/cats/data/Const.scala | 22 ++++---- core/src/main/scala/cats/data/Coproduct.scala | 14 ++--- core/src/main/scala/cats/data/Func.scala | 6 +- core/src/main/scala/cats/data/Ior.scala | 10 ++-- core/src/main/scala/cats/data/Kleisli.scala | 48 ++++++++-------- core/src/main/scala/cats/data/OneAnd.scala | 18 +++--- core/src/main/scala/cats/data/OptionT.scala | 10 ++-- core/src/main/scala/cats/data/Prod.scala | 14 ++--- core/src/main/scala/cats/data/StateT.scala | 4 +- core/src/main/scala/cats/data/Validated.scala | 12 ++-- core/src/main/scala/cats/data/WriterT.scala | 56 +++++++++---------- core/src/main/scala/cats/data/Xor.scala | 18 +++--- core/src/main/scala/cats/data/XorT.scala | 26 ++++----- 14 files changed, 135 insertions(+), 135 deletions(-) diff --git a/core/src/main/scala/cats/data/Cokleisli.scala b/core/src/main/scala/cats/data/Cokleisli.scala index 4aa36b0d55b..71fce01d4a9 100644 --- a/core/src/main/scala/cats/data/Cokleisli.scala +++ b/core/src/main/scala/cats/data/Cokleisli.scala @@ -44,10 +44,10 @@ object Cokleisli extends CokleisliInstances { } private[data] sealed abstract class CokleisliInstances extends CokleisliInstances0 { - implicit def cokleisliArrow[F[_]](implicit ev: Comonad[F]): Arrow[Cokleisli[F, ?, ?]] = + implicit def catsArrowForCokleisli[F[_]](implicit ev: Comonad[F]): Arrow[Cokleisli[F, ?, ?]] = new CokleisliArrow[F] { def F: Comonad[F] = ev } - implicit def cokleisliMonad[F[_], A]: Monad[Cokleisli[F, A, ?]] = new Monad[Cokleisli[F, A, ?]] { + implicit def catsMonadForCokleisli[F[_], A]: Monad[Cokleisli[F, A, ?]] = new Monad[Cokleisli[F, A, ?]] { def pure[B](x: B): Cokleisli[F, A, B] = Cokleisli.pure(x) @@ -58,18 +58,18 @@ private[data] sealed abstract class CokleisliInstances extends CokleisliInstance fa.map(f) } - implicit def cokleisliMonoidK[F[_]](implicit ev: Comonad[F]): MonoidK[Lambda[A => Cokleisli[F, A, A]]] = + implicit def catsMonoidKForCokleisli[F[_]](implicit ev: Comonad[F]): MonoidK[Lambda[A => Cokleisli[F, A, A]]] = new CokleisliMonoidK[F] { def F: Comonad[F] = ev } } private[data] sealed abstract class CokleisliInstances0 { - implicit def cokleisliSplit[F[_]](implicit ev: CoflatMap[F]): Split[Cokleisli[F, ?, ?]] = + implicit def catsSplitForCokleisli[F[_]](implicit ev: CoflatMap[F]): Split[Cokleisli[F, ?, ?]] = new CokleisliSplit[F] { def F: CoflatMap[F] = ev } - implicit def cokleisliProfunctor[F[_]](implicit ev: Functor[F]): Profunctor[Cokleisli[F, ?, ?]] = + implicit def catsProfunctorForCokleisli[F[_]](implicit ev: Functor[F]): Profunctor[Cokleisli[F, ?, ?]] = new CokleisliProfunctor[F] { def F: Functor[F] = ev } - implicit def cokleisliSemigroupK[F[_]](implicit ev: CoflatMap[F]): SemigroupK[Lambda[A => Cokleisli[F, A, A]]] = + implicit def catsSemigroupKForCokleisli[F[_]](implicit ev: CoflatMap[F]): SemigroupK[Lambda[A => Cokleisli[F, A, A]]] = new CokleisliSemigroupK[F] { def F: CoflatMap[F] = ev } } diff --git a/core/src/main/scala/cats/data/Const.scala b/core/src/main/scala/cats/data/Const.scala index 32fc1e3b91c..723b053e41c 100644 --- a/core/src/main/scala/cats/data/Const.scala +++ b/core/src/main/scala/cats/data/Const.scala @@ -39,21 +39,21 @@ object Const extends ConstInstances { } private[data] sealed abstract class ConstInstances extends ConstInstances0 { - implicit def constOrder[A: Order, B]: Order[Const[A, B]] = new Order[Const[A, B]] { + implicit def catsOrderForConst[A: Order, B]: Order[Const[A, B]] = new Order[Const[A, B]] { def compare(x: Const[A, B], y: Const[A, B]): Int = x compare y } - implicit def constShow[A: Show, B]: Show[Const[A, B]] = new Show[Const[A, B]] { + implicit def catsShowForConst[A: Show, B]: Show[Const[A, B]] = new Show[Const[A, B]] { def show(f: Const[A, B]): String = f.show } - implicit def constContravariant[C]: Contravariant[Const[C, ?]] = new Contravariant[Const[C, ?]] { + implicit def catsContravariantForConst[C]: Contravariant[Const[C, ?]] = new Contravariant[Const[C, ?]] { override def contramap[A, B](fa: Const[C, A])(f: (B) => A): Const[C, B] = fa.retag[B] } - implicit def constTraverse[C]: Traverse[Const[C, ?]] = new Traverse[Const[C, ?]] { + implicit def catsTraverseForConst[C]: Traverse[Const[C, ?]] = new Traverse[Const[C, ?]] { def traverse[G[_]: Applicative, A, B](fa: Const[C, A])(f: A => G[B]): G[Const[C, B]] = fa.traverse(f) @@ -62,7 +62,7 @@ private[data] sealed abstract class ConstInstances extends ConstInstances0 { def foldRight[A, B](fa: Const[C, A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B] = lb } - implicit def constMonoid[A: Monoid, B]: Monoid[Const[A, B]] = new Monoid[Const[A, B]]{ + implicit def catsMonoidForConst[A: Monoid, B]: Monoid[Const[A, B]] = new Monoid[Const[A, B]]{ def empty: Const[A, B] = Const.empty @@ -70,7 +70,7 @@ private[data] sealed abstract class ConstInstances extends ConstInstances0 { x combine y } - implicit val constBifoldable: Bifoldable[Const] = + implicit val catsBifoldableForConst: Bifoldable[Const] = new Bifoldable[Const] { def bifoldLeft[A, B, C](fab: Const[A, B], c: C)(f: (C, A) => C, g: (C, B) => C): C = f(c, fab.getConst) @@ -82,16 +82,16 @@ private[data] sealed abstract class ConstInstances extends ConstInstances0 { private[data] sealed abstract class ConstInstances0 extends ConstInstances1 { - implicit def constSemigroup[A: Semigroup, B]: Semigroup[Const[A, B]] = new Semigroup[Const[A, B]] { + implicit def catsSemigroupForConst[A: Semigroup, B]: Semigroup[Const[A, B]] = new Semigroup[Const[A, B]] { def combine(x: Const[A, B], y: Const[A, B]): Const[A, B] = x combine y } - implicit def constPartialOrder[A: PartialOrder, B]: PartialOrder[Const[A, B]] = new PartialOrder[Const[A, B]]{ + implicit def catsPartialOrderForConst[A: PartialOrder, B]: PartialOrder[Const[A, B]] = new PartialOrder[Const[A, B]]{ def partialCompare(x: Const[A, B], y: Const[A, B]): Double = x partialCompare y } - implicit def constApplicative[C: Monoid]: Applicative[Const[C, ?]] = new Applicative[Const[C, ?]] { + implicit def catsApplicativeForConst[C: Monoid]: Applicative[Const[C, ?]] = new Applicative[Const[C, ?]] { def pure[A](x: A): Const[C, A] = Const.empty @@ -107,12 +107,12 @@ private[data] sealed abstract class ConstInstances0 extends ConstInstances1 { } private[data] sealed abstract class ConstInstances1 { - implicit def constEq[A: Eq, B]: Eq[Const[A, B]] = new Eq[Const[A, B]] { + implicit def catsEqForConst[A: Eq, B]: Eq[Const[A, B]] = new Eq[Const[A, B]] { def eqv(x: Const[A, B], y: Const[A, B]): Boolean = x === y } - implicit def constApply[C: Semigroup]: Apply[Const[C, ?]] = new Apply[Const[C, ?]] { + implicit def catsApplyForConst[C: Semigroup]: Apply[Const[C, ?]] = new Apply[Const[C, ?]] { def ap[A, B](f: Const[C, A => B])(fa: Const[C, A]): Const[C, B] = fa.retag[B] combine f.retag[B] diff --git a/core/src/main/scala/cats/data/Coproduct.scala b/core/src/main/scala/cats/data/Coproduct.scala index 8e963b07a5f..d66582cea2e 100644 --- a/core/src/main/scala/cats/data/Coproduct.scala +++ b/core/src/main/scala/cats/data/Coproduct.scala @@ -105,17 +105,17 @@ object Coproduct extends CoproductInstances { private[data] sealed abstract class CoproductInstances3 { - implicit def coproductEq[F[_], G[_], A](implicit E: Eq[F[A] Xor G[A]]): Eq[Coproduct[F, G, A]] = + implicit def catsEqForCoproduct[F[_], G[_], A](implicit E: Eq[F[A] Xor G[A]]): Eq[Coproduct[F, G, A]] = Eq.by(_.run) - implicit def coproductFunctor[F[_], G[_]](implicit F0: Functor[F], G0: Functor[G]): Functor[Coproduct[F, G, ?]] = + implicit def catsFunctorForCoproduct[F[_], G[_]](implicit F0: Functor[F], G0: Functor[G]): Functor[Coproduct[F, G, ?]] = new CoproductFunctor[F, G] { implicit def F: Functor[F] = F0 implicit def G: Functor[G] = G0 } - implicit def coproductFoldable[F[_], G[_]](implicit F0: Foldable[F], G0: Foldable[G]): Foldable[Coproduct[F, G, ?]] = + implicit def catsFoldableForCoproduct[F[_], G[_]](implicit F0: Foldable[F], G0: Foldable[G]): Foldable[Coproduct[F, G, ?]] = new CoproductFoldable[F, G] { implicit def F: Foldable[F] = F0 @@ -125,7 +125,7 @@ private[data] sealed abstract class CoproductInstances3 { private[data] sealed abstract class CoproductInstances2 extends CoproductInstances3 { - implicit def coproductContravariant[F[_], G[_]](implicit F0: Contravariant[F], G0: Contravariant[G]): Contravariant[Coproduct[F, G, ?]] = + implicit def catsContravariantForCoproduct[F[_], G[_]](implicit F0: Contravariant[F], G0: Contravariant[G]): Contravariant[Coproduct[F, G, ?]] = new CoproductContravariant[F, G] { implicit def F: Contravariant[F] = F0 @@ -134,7 +134,7 @@ private[data] sealed abstract class CoproductInstances2 extends CoproductInstanc } private[data] sealed abstract class CoproductInstances1 extends CoproductInstances2 { - implicit def coproductCoflatMap[F[_], G[_]](implicit F0: CoflatMap[F], G0: CoflatMap[G]): CoflatMap[Coproduct[F, G, ?]] = + implicit def catsCoflatMapForCoproduct[F[_], G[_]](implicit F0: CoflatMap[F], G0: CoflatMap[G]): CoflatMap[Coproduct[F, G, ?]] = new CoproductCoflatMap[F, G] { implicit def F: CoflatMap[F] = F0 @@ -143,7 +143,7 @@ private[data] sealed abstract class CoproductInstances1 extends CoproductInstanc } private[data] sealed abstract class CoproductInstances0 extends CoproductInstances1 { - implicit def coproductTraverse[F[_], G[_]](implicit F0: Traverse[F], G0: Traverse[G]): Traverse[Coproduct[F, G, ?]] = + implicit def catsTraverseForCoproduct[F[_], G[_]](implicit F0: Traverse[F], G0: Traverse[G]): Traverse[Coproduct[F, G, ?]] = new CoproductTraverse[F, G] { implicit def F: Traverse[F] = F0 @@ -153,7 +153,7 @@ private[data] sealed abstract class CoproductInstances0 extends CoproductInstanc sealed abstract class CoproductInstances extends CoproductInstances0 { - implicit def coproductComonad[F[_], G[_]](implicit F0: Comonad[F], G0: Comonad[G]): Comonad[Coproduct[F, G, ?]] = + implicit def catsComonadForCoproduct[F[_], G[_]](implicit F0: Comonad[F], G0: Comonad[G]): Comonad[Coproduct[F, G, ?]] = new CoproductComonad[F, G] { implicit def F: Comonad[F] = F0 diff --git a/core/src/main/scala/cats/data/Func.scala b/core/src/main/scala/cats/data/Func.scala index 54487031ff4..96bca7cc445 100644 --- a/core/src/main/scala/cats/data/Func.scala +++ b/core/src/main/scala/cats/data/Func.scala @@ -32,21 +32,21 @@ object Func extends FuncInstances { } private[data] abstract class FuncInstances extends FuncInstances0 { - implicit def funcApplicative[F[_], C](implicit FF: Applicative[F]): Applicative[Lambda[X => Func[F, C, X]]] = + implicit def catsApplicativeForFunc[F[_], C](implicit FF: Applicative[F]): Applicative[Lambda[X => Func[F, C, X]]] = new FuncApplicative[F, C] { def F: Applicative[F] = FF } } private[data] abstract class FuncInstances0 extends FuncInstances1 { - implicit def funcApply[F[_], C](implicit FF: Apply[F]): Apply[Lambda[X => Func[F, C, X]]] = + implicit def catsApplyForFunc[F[_], C](implicit FF: Apply[F]): Apply[Lambda[X => Func[F, C, X]]] = new FuncApply[F, C] { def F: Apply[F] = FF } } private[data] abstract class FuncInstances1 { - implicit def funcFunctor[F[_], C](implicit FF: Functor[F]): Functor[Lambda[X => Func[F, C, X]]] = + implicit def catsFunctorForFunc[F[_], C](implicit FF: Functor[F]): Functor[Lambda[X => Func[F, C, X]]] = new FuncFunctor[F, C] { def F: Functor[F] = FF } diff --git a/core/src/main/scala/cats/data/Ior.scala b/core/src/main/scala/cats/data/Ior.scala index 8ad8e6e6f6e..0cffc2de606 100644 --- a/core/src/main/scala/cats/data/Ior.scala +++ b/core/src/main/scala/cats/data/Ior.scala @@ -132,20 +132,20 @@ object Ior extends IorInstances with IorFunctions { } private[data] sealed abstract class IorInstances extends IorInstances0 { - implicit def iorEq[A: Eq, B: Eq]: Eq[A Ior B] = new Eq[A Ior B] { + implicit def catsEqForIor[A: Eq, B: Eq]: Eq[A Ior B] = new Eq[A Ior B] { def eqv(x: A Ior B, y: A Ior B): Boolean = x === y } - implicit def iorShow[A: Show, B: Show]: Show[A Ior B] = new Show[A Ior B] { + implicit def catsShowForIor[A: Show, B: Show]: Show[A Ior B] = new Show[A Ior B] { def show(f: A Ior B): String = f.show } - implicit def iorMonad[A: Semigroup]: Monad[A Ior ?] = new Monad[A Ior ?] { + implicit def catsMonadForIor[A: Semigroup]: Monad[A Ior ?] = new Monad[A Ior ?] { def pure[B](b: B): A Ior B = Ior.right(b) def flatMap[B, C](fa: A Ior B)(f: B => A Ior C): A Ior C = fa.flatMap(f) } - implicit def iorBifunctor: Bifunctor[Ior] = + implicit def catsBifunctorForIor: Bifunctor[Ior] = new Bifunctor[Ior] { override def bimap[A, B, C, D](fab: A Ior B)(f: A => C, g: B => D): C Ior D = fab.bimap(f, g) } @@ -153,7 +153,7 @@ private[data] sealed abstract class IorInstances extends IorInstances0 { private[data] sealed abstract class IorInstances0 { - implicit def iorInstances[A]: Traverse[A Ior ?] with Functor[A Ior ?] = new Traverse[A Ior ?] with Functor[A Ior ?] { + implicit def catsTraverseFunctorForIor[A]: Traverse[A Ior ?] with Functor[A Ior ?] = new Traverse[A Ior ?] with Functor[A Ior ?] { def traverse[F[_]: Applicative, B, C](fa: A Ior B)(f: B => F[C]): F[A Ior C] = fa.traverse(f) def foldLeft[B, C](fa: A Ior B, b: C)(f: (C, B) => C): C = diff --git a/core/src/main/scala/cats/data/Kleisli.scala b/core/src/main/scala/cats/data/Kleisli.scala index 83c3ca502e0..11bda7f60b2 100644 --- a/core/src/main/scala/cats/data/Kleisli.scala +++ b/core/src/main/scala/cats/data/Kleisli.scala @@ -79,22 +79,22 @@ private[data] sealed trait KleisliFunctions { private[data] sealed abstract class KleisliInstances extends KleisliInstances0 { - implicit def kleisliMonoid[F[_], A, B](implicit M: Monoid[F[B]]): Monoid[Kleisli[F, A, B]] = + implicit def catsMonoidForKleisli[F[_], A, B](implicit M: Monoid[F[B]]): Monoid[Kleisli[F, A, B]] = new KleisliMonoid[F, A, B] { def FB: Monoid[F[B]] = M } - implicit def kleisliMonoidK[F[_]](implicit M: Monad[F]): MonoidK[Lambda[A => Kleisli[F, A, A]]] = + implicit def catsMonoidKForKleisli[F[_]](implicit M: Monad[F]): MonoidK[Lambda[A => Kleisli[F, A, A]]] = new KleisliMonoidK[F] { def F: Monad[F] = M } - implicit val kleisliIdMonoidK: MonoidK[Lambda[A => Kleisli[Id, A, A]]] = - kleisliMonoidK[Id] + implicit val catsMonoidKForKleisliId: MonoidK[Lambda[A => Kleisli[Id, A, A]]] = + catsMonoidKForKleisli[Id] - implicit def kleisliArrow[F[_]](implicit ev: Monad[F]): Arrow[Kleisli[F, ?, ?]] = + implicit def catsArrowForKleisli[F[_]](implicit ev: Monad[F]): Arrow[Kleisli[F, ?, ?]] = new KleisliArrow[F] { def F: Monad[F] = ev } - implicit val kleisliIdArrow: Arrow[Kleisli[Id, ?, ?]] = - kleisliArrow[Id] + implicit val catsArrowForKleisliId: Arrow[Kleisli[Id, ?, ?]] = + catsArrowForKleisli[Id] - implicit def kleisliChoice[F[_]](implicit ev: Monad[F]): Choice[Kleisli[F, ?, ?]] = + implicit def catsChoiceForKleisli[F[_]](implicit ev: Monad[F]): Choice[Kleisli[F, ?, ?]] = new Choice[Kleisli[F, ?, ?]] { def id[A]: Kleisli[F, A, A] = Kleisli(ev.pure(_)) @@ -105,37 +105,37 @@ private[data] sealed abstract class KleisliInstances extends KleisliInstances0 { f.compose(g) } - implicit val kleisliIdChoice: Choice[Kleisli[Id, ?, ?]] = - kleisliChoice[Id] + implicit val catsChoiceForKleisliId: Choice[Kleisli[Id, ?, ?]] = + catsChoiceForKleisli[Id] - implicit def kleisliIdMonadReader[A]: MonadReader[Kleisli[Id, A, ?], A] = - kleisliMonadReader[Id, A] + implicit def catsMonadReaderForKleisliId[A]: MonadReader[Kleisli[Id, A, ?], A] = + catsMonadReaderForKleisli[Id, A] - implicit def kleisliContravariant[F[_], C]: Contravariant[Kleisli[F, ?, C]] = + implicit def catsContravariantForKleisli[F[_], C]: Contravariant[Kleisli[F, ?, C]] = new Contravariant[Kleisli[F, ?, C]] { override def contramap[A, B](fa: Kleisli[F, A, C])(f: (B) => A): Kleisli[F, B, C] = fa.local(f) } - implicit def kleisliTransLift[A]: TransLift.AuxId[Kleisli[?[_], A, ?]] = + implicit def catsTransLiftForKleisli[A]: TransLift.AuxId[Kleisli[?[_], A, ?]] = new TransLift[Kleisli[?[_], A, ?]] { type TC[M[_]] = Trivial def liftT[M[_], B](ma: M[B])(implicit ev: Trivial): Kleisli[M, A, B] = Kleisli[M, A, B](a => ma) } - implicit def kleisliApplicativeError[F[_], A, E](implicit AE: ApplicativeError[F, E]): ApplicativeError[Kleisli[F, A, ?], E] + implicit def catsApplicativeErrorForKleisli[F[_], A, E](implicit AE: ApplicativeError[F, E]): ApplicativeError[Kleisli[F, A, ?], E] = new KleisliApplicativeError[F, A, E] { implicit def AF: ApplicativeError[F, E] = AE } } private[data] sealed abstract class KleisliInstances0 extends KleisliInstances1 { - implicit def kleisliSplit[F[_]](implicit ev: FlatMap[F]): Split[Kleisli[F, ?, ?]] = + implicit def catsSplitForKleisli[F[_]](implicit ev: FlatMap[F]): Split[Kleisli[F, ?, ?]] = new KleisliSplit[F] { def F: FlatMap[F] = ev } - implicit def kleisliStrong[F[_]](implicit ev: Functor[F]): Strong[Kleisli[F, ?, ?]] = + implicit def catsStrongForKleisli[F[_]](implicit ev: Functor[F]): Strong[Kleisli[F, ?, ?]] = new KleisliStrong[F] { def F: Functor[F] = ev } - implicit def kleisliFlatMap[F[_]: FlatMap, A]: FlatMap[Kleisli[F, A, ?]] = new FlatMap[Kleisli[F, A, ?]] { + implicit def catsFlatMapForKleisli[F[_]: FlatMap, A]: FlatMap[Kleisli[F, A, ?]] = new FlatMap[Kleisli[F, A, ?]] { def flatMap[B, C](fa: Kleisli[F, A, B])(f: B => Kleisli[F, A, C]): Kleisli[F, A, C] = fa.flatMap(f) @@ -143,22 +143,22 @@ private[data] sealed abstract class KleisliInstances0 extends KleisliInstances1 fa.map(f) } - implicit def kleisliSemigroup[F[_], A, B](implicit M: Semigroup[F[B]]): Semigroup[Kleisli[F, A, B]] = + implicit def catsSemigroupForKleisli[F[_], A, B](implicit M: Semigroup[F[B]]): Semigroup[Kleisli[F, A, B]] = new KleisliSemigroup[F, A, B] { def FB: Semigroup[F[B]] = M } - implicit def kleisliSemigroupK[F[_]](implicit ev: FlatMap[F]): SemigroupK[Lambda[A => Kleisli[F, A, A]]] = + implicit def catsSemigroupKForKleisli[F[_]](implicit ev: FlatMap[F]): SemigroupK[Lambda[A => Kleisli[F, A, A]]] = new KleisliSemigroupK[F] { def F: FlatMap[F] = ev } } private[data] sealed abstract class KleisliInstances1 extends KleisliInstances2 { - implicit def kleisliApplicative[F[_], A](implicit A : Applicative[F]): Applicative[Kleisli[F, A, ?]] = new KleisliApplicative[F, A] { + implicit def catsApplicativeForKleisli[F[_], A](implicit A : Applicative[F]): Applicative[Kleisli[F, A, ?]] = new KleisliApplicative[F, A] { implicit def F: Applicative[F] = A } } private[data] sealed abstract class KleisliInstances2 extends KleisliInstances3 { - implicit def kleisliApply[F[_]: Apply, A]: Apply[Kleisli[F, A, ?]] = new Apply[Kleisli[F, A, ?]] { + implicit def catsApplyForKleisli[F[_]: Apply, A]: Apply[Kleisli[F, A, ?]] = new Apply[Kleisli[F, A, ?]] { def ap[B, C](f: Kleisli[F, A, B => C])(fa: Kleisli[F, A, B]): Kleisli[F, A, C] = fa.ap(f) @@ -171,7 +171,7 @@ private[data] sealed abstract class KleisliInstances2 extends KleisliInstances3 } private[data] sealed abstract class KleisliInstances3 extends KleisliInstances4 { - implicit def kleisliFunctor[F[_]: Functor, A]: Functor[Kleisli[F, A, ?]] = new Functor[Kleisli[F, A, ?]] { + implicit def catsFunctorForKleisli[F[_]: Functor, A]: Functor[Kleisli[F, A, ?]] = new Functor[Kleisli[F, A, ?]] { def map[B, C](fa: Kleisli[F, A, B])(f: B => C): Kleisli[F, A, C] = fa.map(f) } @@ -179,7 +179,7 @@ private[data] sealed abstract class KleisliInstances3 extends KleisliInstances4 private[data] sealed abstract class KleisliInstances4 { - implicit def kleisliMonadReader[F[_]: Monad, A]: MonadReader[Kleisli[F, A, ?], A] = + implicit def catsMonadReaderForKleisli[F[_]: Monad, A]: MonadReader[Kleisli[F, A, ?], A] = new MonadReader[Kleisli[F, A, ?], A] { def pure[B](x: B): Kleisli[F, A, B] = Kleisli.pure[F, A, B](x) diff --git a/core/src/main/scala/cats/data/OneAnd.scala b/core/src/main/scala/cats/data/OneAnd.scala index 84f81d9bc7a..58399c9b311 100644 --- a/core/src/main/scala/cats/data/OneAnd.scala +++ b/core/src/main/scala/cats/data/OneAnd.scala @@ -96,29 +96,29 @@ final case class OneAnd[F[_], A](head: A, tail: F[A]) { private[data] sealed trait OneAndInstances extends OneAndLowPriority2 { - implicit def oneAndEq[A, F[_]](implicit A: Eq[A], FA: Eq[F[A]]): Eq[OneAnd[F, A]] = + implicit def catsEqForOneAnd[A, F[_]](implicit A: Eq[A], FA: Eq[F[A]]): Eq[OneAnd[F, A]] = new Eq[OneAnd[F, A]]{ def eqv(x: OneAnd[F, A], y: OneAnd[F, A]): Boolean = x === y } - implicit def oneAndShow[A, F[_]](implicit A: Show[A], FA: Show[F[A]]): Show[OneAnd[F, A]] = + implicit def catsShowForOneAnd[A, F[_]](implicit A: Show[A], FA: Show[F[A]]): Show[OneAnd[F, A]] = Show.show[OneAnd[F, A]](_.show) - implicit def oneAndSemigroupK[F[_]: MonadCombine]: SemigroupK[OneAnd[F, ?]] = + implicit def catsSemigroupKForOneAnd[F[_]: MonadCombine]: SemigroupK[OneAnd[F, ?]] = new SemigroupK[OneAnd[F, ?]] { def combineK[A](a: OneAnd[F, A], b: OneAnd[F, A]): OneAnd[F, A] = a combine b } - implicit def oneAndSemigroup[F[_]: MonadCombine, A]: Semigroup[OneAnd[F, A]] = - oneAndSemigroupK[F].algebra + implicit def catsSemigroupForOneAnd[F[_]: MonadCombine, A]: Semigroup[OneAnd[F, A]] = + catsSemigroupKForOneAnd[F].algebra - implicit def oneAndReducible[F[_]](implicit F: Foldable[F]): Reducible[OneAnd[F, ?]] = + implicit def catsReducibleForOneAnd[F[_]](implicit F: Foldable[F]): Reducible[OneAnd[F, ?]] = new NonEmptyReducible[OneAnd[F,?], F] { override def split[A](fa: OneAnd[F,A]): (A, F[A]) = (fa.head, fa.tail) } - implicit def oneAndMonad[F[_]](implicit monad: MonadCombine[F]): Monad[OneAnd[F, ?]] = + implicit def catsMonadForOneAnd[F[_]](implicit monad: MonadCombine[F]): Monad[OneAnd[F, ?]] = new Monad[OneAnd[F, ?]] { override def map[A, B](fa: OneAnd[F, A])(f: A => B): OneAnd[F, B] = fa map f @@ -158,7 +158,7 @@ trait OneAndLowPriority0 { } trait OneAndLowPriority1 extends OneAndLowPriority0 { - implicit def oneAndFunctor[F[_]](implicit F: Functor[F]): Functor[OneAnd[F, ?]] = + implicit def catsFunctorForOneAnd[F[_]](implicit F: Functor[F]): Functor[OneAnd[F, ?]] = new Functor[OneAnd[F, ?]] { def map[A, B](fa: OneAnd[F, A])(f: A => B): OneAnd[F, B] = fa map f @@ -167,7 +167,7 @@ trait OneAndLowPriority1 extends OneAndLowPriority0 { } trait OneAndLowPriority2 extends OneAndLowPriority1 { - implicit def oneAndTraverse[F[_]](implicit F: Traverse[F]): Traverse[OneAnd[F, ?]] = + implicit def catsTraverseForOneAnd[F[_]](implicit F: Traverse[F]): Traverse[OneAnd[F, ?]] = new Traverse[OneAnd[F, ?]] { def traverse[G[_], A, B](fa: OneAnd[F, A])(f: (A) => G[B])(implicit G: Applicative[G]): G[OneAnd[F, B]] = { G.map2Eval(f(fa.head), Always(F.traverse(fa.tail)(f)))(OneAnd(_, _)).value diff --git a/core/src/main/scala/cats/data/OptionT.scala b/core/src/main/scala/cats/data/OptionT.scala index 6db53b4243c..09b68e4e00f 100644 --- a/core/src/main/scala/cats/data/OptionT.scala +++ b/core/src/main/scala/cats/data/OptionT.scala @@ -133,14 +133,14 @@ object OptionT extends OptionTInstances { } private[data] sealed trait OptionTInstances1 { - implicit def optionTFunctor[F[_]:Functor]: Functor[OptionT[F, ?]] = + implicit def catsFunctorForOptionT[F[_]:Functor]: Functor[OptionT[F, ?]] = new Functor[OptionT[F, ?]] { override def map[A, B](fa: OptionT[F, A])(f: A => B): OptionT[F, B] = fa.map(f) } // do NOT change this to val! I know it looks like it should work, and really I agree, but it doesn't (for... reasons) - implicit def optionTTransLift: TransLift.Aux[OptionT, Functor] = + implicit def catsTransLiftForOptionT: TransLift.Aux[OptionT, Functor] = new TransLift[OptionT] { type TC[M[_]] = Functor[M] @@ -150,7 +150,7 @@ private[data] sealed trait OptionTInstances1 { private[data] sealed trait OptionTInstances extends OptionTInstances1 { - implicit def optionTMonad[F[_]](implicit F: Monad[F]): Monad[OptionT[F, ?]] = + implicit def catsMonadForOptionT[F[_]](implicit F: Monad[F]): Monad[OptionT[F, ?]] = new Monad[OptionT[F, ?]] { def pure[A](a: A): OptionT[F, A] = OptionT.pure(a) @@ -161,9 +161,9 @@ private[data] sealed trait OptionTInstances extends OptionTInstances1 { fa.map(f) } - implicit def optionTEq[F[_], A](implicit FA: Eq[F[Option[A]]]): Eq[OptionT[F, A]] = + implicit def catsEqForOptionT[F[_], A](implicit FA: Eq[F[Option[A]]]): Eq[OptionT[F, A]] = FA.on(_.value) - implicit def optionTShow[F[_], A](implicit F: Show[F[Option[A]]]): Show[OptionT[F, A]] = + implicit def catsShowForOptionT[F[_], A](implicit F: Show[F[Option[A]]]): Show[OptionT[F, A]] = functor.Contravariant[Show].contramap(F)(_.value) } diff --git a/core/src/main/scala/cats/data/Prod.scala b/core/src/main/scala/cats/data/Prod.scala index 202c49a2342..5d32709d8fd 100644 --- a/core/src/main/scala/cats/data/Prod.scala +++ b/core/src/main/scala/cats/data/Prod.scala @@ -11,47 +11,47 @@ final case class Prod[F[_], G[_], A](first: F[A], second: G[A]) object Prod extends ProdInstances private[data] sealed abstract class ProdInstances extends ProdInstances0 { - implicit def prodAlternative[F[_], G[_]](implicit FF: Alternative[F], GG: Alternative[G]): Alternative[Lambda[X => Prod[F, G, X]]] = new ProdAlternative[F, G] { + implicit def catsAlternativeForProd[F[_], G[_]](implicit FF: Alternative[F], GG: Alternative[G]): Alternative[Lambda[X => Prod[F, G, X]]] = new ProdAlternative[F, G] { def F: Alternative[F] = FF def G: Alternative[G] = GG } - implicit def prodEq[F[_], G[_], A](implicit FF: Eq[F[A]], GG: Eq[G[A]]): Eq[Prod[F, G, A]] = new Eq[Prod[F, G, A]] { + implicit def catsEqForProd[F[_], G[_], A](implicit FF: Eq[F[A]], GG: Eq[G[A]]): Eq[Prod[F, G, A]] = new Eq[Prod[F, G, A]] { def eqv(x: Prod[F, G, A], y: Prod[F, G, A]): Boolean = FF.eqv(x.first, y.first) && GG.eqv(x.second, y.second) } } private[data] sealed abstract class ProdInstances0 extends ProdInstances1 { - implicit def prodMonoidK[F[_], G[_]](implicit FF: MonoidK[F], GG: MonoidK[G]): MonoidK[Lambda[X => Prod[F, G, X]]] = new ProdMonoidK[F, G] { + implicit def catsMonoidKForProd[F[_], G[_]](implicit FF: MonoidK[F], GG: MonoidK[G]): MonoidK[Lambda[X => Prod[F, G, X]]] = new ProdMonoidK[F, G] { def F: MonoidK[F] = FF def G: MonoidK[G] = GG } } private[data] sealed abstract class ProdInstances1 extends ProdInstances2 { - implicit def prodSemigroupK[F[_], G[_]](implicit FF: SemigroupK[F], GG: SemigroupK[G]): SemigroupK[Lambda[X => Prod[F, G, X]]] = new ProdSemigroupK[F, G] { + implicit def catsSemigroupKForProd[F[_], G[_]](implicit FF: SemigroupK[F], GG: SemigroupK[G]): SemigroupK[Lambda[X => Prod[F, G, X]]] = new ProdSemigroupK[F, G] { def F: SemigroupK[F] = FF def G: SemigroupK[G] = GG } } private[data] sealed abstract class ProdInstances2 extends ProdInstances3 { - implicit def prodApplicative[F[_], G[_]](implicit FF: Applicative[F], GG: Applicative[G]): Applicative[Lambda[X => Prod[F, G, X]]] = new ProdApplicative[F, G] { + implicit def catsApplicativeForProd[F[_], G[_]](implicit FF: Applicative[F], GG: Applicative[G]): Applicative[Lambda[X => Prod[F, G, X]]] = new ProdApplicative[F, G] { def F: Applicative[F] = FF def G: Applicative[G] = GG } } private[data] sealed abstract class ProdInstances3 extends ProdInstances4 { - implicit def prodApply[F[_], G[_]](implicit FF: Apply[F], GG: Apply[G]): Apply[Lambda[X => Prod[F, G, X]]] = new ProdApply[F, G] { + implicit def catsApplyForProd[F[_], G[_]](implicit FF: Apply[F], GG: Apply[G]): Apply[Lambda[X => Prod[F, G, X]]] = new ProdApply[F, G] { def F: Apply[F] = FF def G: Apply[G] = GG } } private[data] sealed abstract class ProdInstances4 { - implicit def prodFunctor[F[_], G[_]](implicit FF: Functor[F], GG: Functor[G]): Functor[Lambda[X => Prod[F, G, X]]] = new ProdFunctor[F, G] { + implicit def catsFunctorForProd[F[_], G[_]](implicit FF: Functor[F], GG: Functor[G]): Functor[Lambda[X => Prod[F, G, X]]] = new ProdFunctor[F, G] { def F: Functor[F] = FF def G: Functor[G] = GG } diff --git a/core/src/main/scala/cats/data/StateT.scala b/core/src/main/scala/cats/data/StateT.scala index f3a2f2b3f41..fd369571192 100644 --- a/core/src/main/scala/cats/data/StateT.scala +++ b/core/src/main/scala/cats/data/StateT.scala @@ -136,7 +136,7 @@ object StateT extends StateTInstances { } private[data] sealed abstract class StateTInstances { - implicit def stateTMonadState[F[_], S](implicit F: Monad[F]): MonadState[StateT[F, S, ?], S] = + implicit def catsMonadStateForStateT[F[_], S](implicit F: Monad[F]): MonadState[StateT[F, S, ?], S] = new MonadState[StateT[F, S, ?], S] { def pure[A](a: A): StateT[F, S, A] = StateT.pure(a) @@ -152,7 +152,7 @@ private[data] sealed abstract class StateTInstances { fa.map(f) } - implicit def stateTLift[S]: TransLift.Aux[StateT[?[_], S, ?], Applicative] = + implicit def catsLiftForStateT[S]: TransLift.Aux[StateT[?[_], S, ?], Applicative] = new TransLift[StateT[?[_], S, ?]] { type TC[M[_]] = Applicative[M] diff --git a/core/src/main/scala/cats/data/Validated.scala b/core/src/main/scala/cats/data/Validated.scala index 6a26c710edd..41d60f77a2c 100644 --- a/core/src/main/scala/cats/data/Validated.scala +++ b/core/src/main/scala/cats/data/Validated.scala @@ -225,7 +225,7 @@ object Validated extends ValidatedInstances with ValidatedFunctions{ private[data] sealed abstract class ValidatedInstances extends ValidatedInstances1 { - implicit def validatedSemigroupK[A](implicit A: Semigroup[A]): SemigroupK[Validated[A,?]] = + implicit def catsSemigroupKForValidated[A](implicit A: Semigroup[A]): SemigroupK[Validated[A,?]] = new SemigroupK[Validated[A,?]] { def combineK[B](x: Validated[A,B], y: Validated[A,B]): Validated[A,B] = x match { case v @ Valid(_) => v @@ -236,22 +236,22 @@ private[data] sealed abstract class ValidatedInstances extends ValidatedInstance } } - implicit def validatedMonoid[A, B](implicit A: Semigroup[A], B: Monoid[B]): Monoid[Validated[A, B]] = new Monoid[Validated[A, B]] { + implicit def catsMonoidForValidated[A, B](implicit A: Semigroup[A], B: Monoid[B]): Monoid[Validated[A, B]] = new Monoid[Validated[A, B]] { def empty: Validated[A, B] = Valid(B.empty) def combine(x: Validated[A, B], y: Validated[A, B]): Validated[A, B] = x combine y } - implicit def validatedOrder[A: Order, B: Order]: Order[Validated[A,B]] = new Order[Validated[A,B]] { + implicit def catsOrderForValidated[A: Order, B: Order]: Order[Validated[A,B]] = new Order[Validated[A,B]] { def compare(x: Validated[A,B], y: Validated[A,B]): Int = x compare y override def partialCompare(x: Validated[A,B], y: Validated[A,B]): Double = x partialCompare y override def eqv(x: Validated[A,B], y: Validated[A,B]): Boolean = x === y } - implicit def validatedShow[A, B](implicit A: Show[A], B: Show[B]): Show[Validated[A,B]] = new Show[Validated[A,B]] { + implicit def catsShowForValidated[A, B](implicit A: Show[A], B: Show[B]): Show[Validated[A,B]] = new Show[Validated[A,B]] { def show(f: Validated[A,B]): String = f.show } - implicit val validatedBitraverse: Bitraverse[Validated] = + implicit val catsBitraverseForValidated: Bitraverse[Validated] = new Bitraverse[Validated] { def bitraverse[G[_], A, B, C, D](fab: Validated[A, B])(f: A => G[C], g: B => G[D])(implicit G: Applicative[G]): G[Validated[C, D]] = fab match { @@ -278,7 +278,7 @@ private[data] sealed abstract class ValidatedInstances extends ValidatedInstance fab.leftMap(f) } - implicit def validatedInstances[E](implicit E: Semigroup[E]): Traverse[Validated[E, ?]] with ApplicativeError[Validated[E, ?], E] = + implicit def catsInstancesForValidated[E](implicit E: Semigroup[E]): Traverse[Validated[E, ?]] with ApplicativeError[Validated[E, ?], E] = new Traverse[Validated[E, ?]] with ApplicativeError[Validated[E, ?], E] { def traverse[F[_]: Applicative, A, B](fa: Validated[E,A])(f: A => F[B]): F[Validated[E,B]] = fa.traverse(f) diff --git a/core/src/main/scala/cats/data/WriterT.scala b/core/src/main/scala/cats/data/WriterT.scala index 2ee07cc5cdc..2ff49610516 100644 --- a/core/src/main/scala/cats/data/WriterT.scala +++ b/core/src/main/scala/cats/data/WriterT.scala @@ -52,19 +52,19 @@ object WriterT extends WriterTInstances with WriterTFunctions private[data] sealed abstract class WriterTInstances extends WriterTInstances0 { - implicit def writerTIdMonad[L:Monoid]: Monad[WriterT[Id, L, ?]] = - writerTMonadWriter[Id, L] + implicit def catsMonadForWriterTId[L:Monoid]: Monad[WriterT[Id, L, ?]] = + catsMonadWriterForWriterT[Id, L] - implicit def writerTIdEq[L: Eq, V: Eq]: Eq[WriterT[Id, L, V]] = - writerTEq[Id, L, V] + implicit def catsEqForWriterTId[L: Eq, V: Eq]: Eq[WriterT[Id, L, V]] = + catsEqForWriterT[Id, L, V] - implicit def writerTBifunctor[F[_]:Functor]: Bifunctor[WriterT[F, ?, ?]] = + implicit def catsBifunctorForWriterT[F[_]:Functor]: Bifunctor[WriterT[F, ?, ?]] = new Bifunctor[WriterT[F, ?, ?]] { def bimap[A, B, C, D](fab: WriterT[F, A, B])(f: A => C, g: B => D): WriterT[F, C, D] = fab.bimap(f, g) } - implicit def writerTTransLift[W](implicit W: Monoid[W]): TransLift.Aux[WriterT[?[_], W, ?], Functor] = + implicit def catsTransLiftForWriterT[W](implicit W: Monoid[W]): TransLift.Aux[WriterT[?[_], W, ?], Functor] = new TransLift[WriterT[?[_], W, ?]] { type TC[M[_]] = Functor[M] @@ -72,61 +72,61 @@ private[data] sealed abstract class WriterTInstances extends WriterTInstances0 { WriterT(Functor[M].map(ma)((W.empty, _))) } - implicit def writerTShow[F[_], L, V](implicit F: Show[F[(L, V)]]): Show[WriterT[F, L, V]] = new Show[WriterT[F, L, V]] { + implicit def catsShowForWriterT[F[_], L, V](implicit F: Show[F[(L, V)]]): Show[WriterT[F, L, V]] = new Show[WriterT[F, L, V]] { override def show(f: WriterT[F, L, V]): String = f.show } - implicit def writerTIdMonoid[L:Monoid, V:Monoid]: Monoid[WriterT[Id, L, V]] = - writerTMonoid[Id, L, V] + implicit def catsMonoidForWriterTId[L:Monoid, V:Monoid]: Monoid[WriterT[Id, L, V]] = + catsMonoidForWriterT[Id, L, V] } private[data] sealed abstract class WriterTInstances0 extends WriterTInstances1 { - implicit def writerTMonadCombine[F[_], L](implicit F: MonadCombine[F], L: Monoid[L]): MonadCombine[WriterT[F, L, ?]] = + implicit def catsMonadCombineForWriterT[F[_], L](implicit F: MonadCombine[F], L: Monoid[L]): MonadCombine[WriterT[F, L, ?]] = new WriterTMonadCombine[F, L] { implicit val F0: MonadCombine[F] = F implicit val L0: Monoid[L] = L } - implicit def writerTIdFunctor[L]: Functor[WriterT[Id, L, ?]] = - writerTFunctor[Id, L] + implicit def catsFunctorForWriterTId[L]: Functor[WriterT[Id, L, ?]] = + catsFunctorForWriterT[Id, L] - implicit def writerTIdFlatMap[L:Semigroup]: FlatMap[WriterT[Id, L, ?]] = - writerTFlatMap[Id, L] + implicit def catsFlatMapForWriterTId[L:Semigroup]: FlatMap[WriterT[Id, L, ?]] = + catsFlatMapForWriterT[Id, L] - implicit def writerTEq[F[_], L, V](implicit F: Eq[F[(L, V)]]): Eq[WriterT[F, L, V]] = + implicit def catsEqForWriterT[F[_], L, V](implicit F: Eq[F[(L, V)]]): Eq[WriterT[F, L, V]] = F.on(_.run) - implicit def writerTIdSemigroup[L:Semigroup, V:Semigroup]: Semigroup[WriterT[Id, L, V]] = - writerTSemigroup[Id, L, V] + implicit def catsSemigroupForWriterTId[L:Semigroup, V:Semigroup]: Semigroup[WriterT[Id, L, V]] = + catsSemigroupForWriterT[Id, L, V] } private[data] sealed abstract class WriterTInstances1 extends WriterTInstances2 { - implicit def writerTMonadFilter[F[_], L](implicit F: MonadFilter[F], L: Monoid[L]): MonadFilter[WriterT[F, L, ?]] = + implicit def catsMonadFilterForWriterT[F[_], L](implicit F: MonadFilter[F], L: Monoid[L]): MonadFilter[WriterT[F, L, ?]] = new WriterTMonadFilter[F, L] { implicit val F0: MonadFilter[F] = F implicit val L0: Monoid[L] = L } - implicit def writerTMonoid[F[_], L, V](implicit W: Monoid[F[(L, V)]]): Monoid[WriterT[F, L, V]] = + implicit def catsMonoidForWriterT[F[_], L, V](implicit W: Monoid[F[(L, V)]]): Monoid[WriterT[F, L, V]] = new WriterTMonoid[F, L, V] { implicit val F0: Monoid[F[(L, V)]] = W } } private[data] sealed abstract class WriterTInstances2 extends WriterTInstances3 { - implicit def writerTMonadWriter[F[_], L](implicit F: Monad[F], L: Monoid[L]): MonadWriter[WriterT[F, L, ?], L] = + implicit def catsMonadWriterForWriterT[F[_], L](implicit F: Monad[F], L: Monoid[L]): MonadWriter[WriterT[F, L, ?], L] = new WriterTMonadWriter[F, L] { implicit val F0: Monad[F] = F implicit val L0: Monoid[L] = L } - implicit def writerTSemigroup[F[_], L, V](implicit W: Semigroup[F[(L, V)]]): Semigroup[WriterT[F, L, V]] = + implicit def catsSemigroupForWriterT[F[_], L, V](implicit W: Semigroup[F[(L, V)]]): Semigroup[WriterT[F, L, V]] = new WriterTSemigroup[F, L, V] { implicit val F0: Semigroup[F[(L, V)]] = W } } private[data] sealed abstract class WriterTInstances3 extends WriterTInstances4 { - implicit def writerTAlternative[F[_], L](implicit F: Alternative[F], L: Monoid[L]): Alternative[WriterT[F, L, ?]] = + implicit def catsAlternativeForWriterT[F[_], L](implicit F: Alternative[F], L: Monoid[L]): Alternative[WriterT[F, L, ?]] = new WriterTAlternative[F, L] { implicit val F0: Alternative[F] = F implicit val L0: Monoid[L] = L @@ -134,33 +134,33 @@ private[data] sealed abstract class WriterTInstances3 extends WriterTInstances4 } private[data] sealed abstract class WriterTInstances4 extends WriterTInstances5 { - implicit def writerTApplicative[F[_], L](implicit F: Applicative[F], L: Monoid[L]): Applicative[WriterT[F, L, ?]] = + implicit def catsApplicativeForWriterT[F[_], L](implicit F: Applicative[F], L: Monoid[L]): Applicative[WriterT[F, L, ?]] = new WriterTApplicative[F, L] { implicit val F0: Applicative[F] = F implicit val L0: Monoid[L] = L } - implicit def writerTMonoidK[F[_], L](implicit F: MonoidK[F]): MonoidK[WriterT[F, L, ?]] = + implicit def catsMonoidKForWriterT[F[_], L](implicit F: MonoidK[F]): MonoidK[WriterT[F, L, ?]] = new WriterTMonoidK[F, L] { implicit val F0: MonoidK[F] = F } } private[data] sealed abstract class WriterTInstances5 extends WriterTInstances6 { - implicit def writerTFlatMap[F[_], L](implicit F: FlatMap[F], L: Semigroup[L]): FlatMap[WriterT[F, L, ?]] = + implicit def catsFlatMapForWriterT[F[_], L](implicit F: FlatMap[F], L: Semigroup[L]): FlatMap[WriterT[F, L, ?]] = new WriterTFlatMap[F, L] { implicit val F0: FlatMap[F] = F implicit val L0: Semigroup[L] = L } - implicit def writerTSemigroupK[F[_], L](implicit F: SemigroupK[F]): SemigroupK[WriterT[F, L, ?]] = + implicit def catsSemigroupKForWriterT[F[_], L](implicit F: SemigroupK[F]): SemigroupK[WriterT[F, L, ?]] = new WriterTSemigroupK[F, L] { implicit val F0: SemigroupK[F] = F } } private[data] sealed abstract class WriterTInstances6 extends WriterTInstances7 { - implicit def writerTApply[F[_], L](implicit F: Apply[F], L: Semigroup[L]): Apply[WriterT[F, L, ?]] = + implicit def catsApplyForWriterT[F[_], L](implicit F: Apply[F], L: Semigroup[L]): Apply[WriterT[F, L, ?]] = new WriterTApply[F, L] { implicit val F0: Apply[F] = F implicit val L0: Semigroup[L] = L @@ -168,7 +168,7 @@ private[data] sealed abstract class WriterTInstances6 extends WriterTInstances7 } private[data] sealed abstract class WriterTInstances7 { - implicit def writerTFunctor[F[_], L](implicit F: Functor[F]): Functor[WriterT[F, L, ?]] = new WriterTFunctor[F, L] { + implicit def catsFunctorForWriterT[F[_], L](implicit F: Functor[F]): Functor[WriterT[F, L, ?]] = new WriterTFunctor[F, L] { implicit val F0: Functor[F] = F } } diff --git a/core/src/main/scala/cats/data/Xor.scala b/core/src/main/scala/cats/data/Xor.scala index 427fd011c1b..1b6f214b1c2 100644 --- a/core/src/main/scala/cats/data/Xor.scala +++ b/core/src/main/scala/cats/data/Xor.scala @@ -186,25 +186,25 @@ object Xor extends XorInstances with XorFunctions { } private[data] sealed abstract class XorInstances extends XorInstances1 { - implicit def xorOrder[A: Order, B: Order]: Order[A Xor B] = + implicit def catsOrderForXor[A: Order, B: Order]: Order[A Xor B] = new Order[A Xor B] { def compare(x: A Xor B, y: A Xor B): Int = x compare y override def partialCompare(x: A Xor B, y: A Xor B): Double = x partialCompare y override def eqv(x: A Xor B, y: A Xor B): Boolean = x === y } - implicit def xorShow[A, B](implicit A: Show[A], B: Show[B]): Show[A Xor B] = + implicit def catsShowForXor[A, B](implicit A: Show[A], B: Show[B]): Show[A Xor B] = new Show[A Xor B] { def show(f: A Xor B): String = f.show } - implicit def xorMonoid[A, B](implicit B: Monoid[B]): Monoid[A Xor B] = + implicit def catsMonoidForXor[A, B](implicit B: Monoid[B]): Monoid[A Xor B] = new Monoid[A Xor B] { def empty: A Xor B = Xor.Right(B.empty) def combine(x: A Xor B, y: A Xor B): A Xor B = x combine y } - implicit def xorSemigroupK[L]: SemigroupK[Xor[L,?]] = + implicit def catsSemigroupKForXor[L]: SemigroupK[Xor[L,?]] = new SemigroupK[Xor[L,?]] { def combineK[A](x: Xor[L,A], y: Xor[L,A]): Xor[L,A] = x match { case Xor.Left(_) => y @@ -212,7 +212,7 @@ private[data] sealed abstract class XorInstances extends XorInstances1 { } } - implicit val xorBitraverse: Bitraverse[Xor] = + implicit val catsBitraverseForXor: Bitraverse[Xor] = new Bitraverse[Xor] { def bitraverse[G[_], A, B, C, D](fab: Xor[A, B])(f: A => G[C], g: B => G[D])(implicit G: Applicative[G]): G[Xor[C, D]] = fab match { @@ -233,7 +233,7 @@ private[data] sealed abstract class XorInstances extends XorInstances1 { } } - implicit def xorInstances[A]: Traverse[A Xor ?] with MonadError[Xor[A, ?], A] = + implicit def catsInstancesForXor[A]: Traverse[A Xor ?] with MonadError[Xor[A, ?], A] = new Traverse[A Xor ?] with MonadError[Xor[A, ?], A] { def traverse[F[_]: Applicative, B, C](fa: A Xor B)(f: B => F[C]): F[A Xor C] = fa.traverse(f) def foldLeft[B, C](fa: A Xor B, c: C)(f: (C, B) => C): C = fa.foldLeft(c)(f) @@ -259,19 +259,19 @@ private[data] sealed abstract class XorInstances extends XorInstances1 { private[data] sealed abstract class XorInstances1 extends XorInstances2 { - implicit def xorSemigroup[A, B](implicit B: Semigroup[B]): Semigroup[A Xor B] = + implicit def catsSemigroupForXor[A, B](implicit B: Semigroup[B]): Semigroup[A Xor B] = new Semigroup[A Xor B] { def combine(x: A Xor B, y: A Xor B): A Xor B = x combine y } - implicit def xorPartialOrder[A: PartialOrder, B: PartialOrder]: PartialOrder[A Xor B] = new PartialOrder[A Xor B] { + implicit def catsPartialOrderForXor[A: PartialOrder, B: PartialOrder]: PartialOrder[A Xor B] = new PartialOrder[A Xor B] { def partialCompare(x: A Xor B, y: A Xor B): Double = x partialCompare y override def eqv(x: A Xor B, y: A Xor B): Boolean = x === y } } private[data] sealed abstract class XorInstances2 { - implicit def xorEq[A: Eq, B: Eq]: Eq[A Xor B] = + implicit def catsEqForXor[A: Eq, B: Eq]: Eq[A Xor B] = new Eq[A Xor B] { def eqv(x: A Xor B, y: A Xor B): Boolean = x === y } diff --git a/core/src/main/scala/cats/data/XorT.scala b/core/src/main/scala/cats/data/XorT.scala index 2fdf95282e7..f6c3ac50712 100644 --- a/core/src/main/scala/cats/data/XorT.scala +++ b/core/src/main/scala/cats/data/XorT.scala @@ -218,27 +218,27 @@ trait XorTFunctions { private[data] abstract class XorTInstances extends XorTInstances1 { /* TODO violates right absorbtion, right distributivity, and left distributivity -- re-enable when MonadCombine laws are split in to weak/strong - implicit def xorTMonadCombine[F[_], L](implicit F: Monad[F], L: Monoid[L]): MonadCombine[XorT[F, L, ?]] = { + implicit def catsMonadCombineForXorT[F[_], L](implicit F: Monad[F], L: Monoid[L]): MonadCombine[XorT[F, L, ?]] = { implicit val F0 = F implicit val L0 = L new XorTMonadCombine[F, L] { implicit val F = F0; implicit val L = L0 } } */ - implicit def xorTOrder[F[_], L, R](implicit F: Order[F[L Xor R]]): Order[XorT[F, L, R]] = + implicit def catsOrderForXorT[F[_], L, R](implicit F: Order[F[L Xor R]]): Order[XorT[F, L, R]] = new XorTOrder[F, L, R] { val F0: Order[F[L Xor R]] = F } - implicit def xorTShow[F[_], L, R](implicit sh: Show[F[L Xor R]]): Show[XorT[F, L, R]] = + implicit def catsShowForXorT[F[_], L, R](implicit sh: Show[F[L Xor R]]): Show[XorT[F, L, R]] = functor.Contravariant[Show].contramap(sh)(_.value) - implicit def xorTBifunctor[F[_]](implicit F: Functor[F]): Bifunctor[XorT[F, ?, ?]] = + implicit def catsBifunctorForXorT[F[_]](implicit F: Functor[F]): Bifunctor[XorT[F, ?, ?]] = new Bifunctor[XorT[F, ?, ?]] { override def bimap[A, B, C, D](fab: XorT[F, A, B])(f: A => C, g: B => D): XorT[F, C, D] = fab.bimap(f, g) } - implicit def xorTTraverse[F[_], L](implicit F: Traverse[F]): Traverse[XorT[F, L, ?]] = + implicit def catsTraverseForXorT[F[_], L](implicit F: Traverse[F]): Traverse[XorT[F, L, ?]] = new XorTTraverse[F, L] { val F0: Traverse[F] = F } @@ -255,36 +255,36 @@ private[data] abstract class XorTInstances extends XorTInstances1 { private[data] abstract class XorTInstances1 extends XorTInstances2 { /* TODO violates monadFilter right empty law -- re-enable when MonadFilter laws are split in to weak/strong - implicit def xorTMonadFilter[F[_], L](implicit F: Monad[F], L: Monoid[L]): MonadFilter[XorT[F, L, ?]] = { + implicit def catsMonadFilterForXorT[F[_], L](implicit F: Monad[F], L: Monoid[L]): MonadFilter[XorT[F, L, ?]] = { implicit val F0 = F implicit val L0 = L new XorTMonadFilter[F, L] { implicit val F = F0; implicit val L = L0 } } */ - implicit def xorTFoldable[F[_], L](implicit F: Foldable[F]): Foldable[XorT[F, L, ?]] = + implicit def catsFoldableForXorT[F[_], L](implicit F: Foldable[F]): Foldable[XorT[F, L, ?]] = new XorTFoldable[F, L] { val F0: Foldable[F] = F } - implicit def xorTPartialOrder[F[_], L, R](implicit F: PartialOrder[F[L Xor R]]): PartialOrder[XorT[F, L, R]] = + implicit def catsPartialOrderForXorT[F[_], L, R](implicit F: PartialOrder[F[L Xor R]]): PartialOrder[XorT[F, L, R]] = new XorTPartialOrder[F, L, R] { val F0: PartialOrder[F[L Xor R]] = F } - implicit def xorTBitraverse[F[_]](implicit F: Traverse[F]): Bitraverse[XorT[F, ?, ?]] = + implicit def catsBitraverseForXorT[F[_]](implicit F: Traverse[F]): Bitraverse[XorT[F, ?, ?]] = new XorTBitraverse[F] { val F0: Traverse[F] = F } } private[data] abstract class XorTInstances2 extends XorTInstances3 { - implicit def xorTMonadError[F[_], L](implicit F: Monad[F]): MonadError[XorT[F, L, ?], L] = { + implicit def catsMonadErrorForXorT[F[_], L](implicit F: Monad[F]): MonadError[XorT[F, L, ?], L] = { implicit val F0 = F new XorTMonadError[F, L] { implicit val F = F0 } } - implicit def xorTSemigroupK[F[_], L](implicit F: Monad[F]): SemigroupK[XorT[F, L, ?]] = + implicit def catsSemigroupKForXorT[F[_], L](implicit F: Monad[F]): SemigroupK[XorT[F, L, ?]] = new SemigroupK[XorT[F,L,?]] { def combineK[A](x: XorT[F,L,A], y: XorT[F, L, A]): XorT[F, L, A] = XorT(F.flatMap(x.value) { @@ -293,14 +293,14 @@ private[data] abstract class XorTInstances2 extends XorTInstances3 { }) } - implicit def xorTEq[F[_], L, R](implicit F: Eq[F[L Xor R]]): Eq[XorT[F, L, R]] = + implicit def catsEqForXorT[F[_], L, R](implicit F: Eq[F[L Xor R]]): Eq[XorT[F, L, R]] = new XorTEq[F, L, R] { val F0: Eq[F[L Xor R]] = F } } private[data] abstract class XorTInstances3 { - implicit def xorTFunctor[F[_], L](implicit F: Functor[F]): Functor[XorT[F, L, ?]] = { + implicit def catsFunctorForXorT[F[_], L](implicit F: Functor[F]): Functor[XorT[F, L, ?]] = { implicit val F0 = F new XorTFunctor[F, L] { implicit val F = F0 } }