diff --git a/.scalafmt.conf b/.scalafmt.conf new file mode 100644 index 00000000..404f5d9f --- /dev/null +++ b/.scalafmt.conf @@ -0,0 +1,15 @@ +version = "2.7.5" +align.preset = none +maxColumn = 120 +includeNoParensInSelectChains = false +includeCurlyBraceInSelectChains = false +trailingCommas = "never" +rewrite.rules = [RedundantBraces, AvoidInfix, SortModifiers, PreferCurlyFors] +rewrite.redundantBraces.stringInterpolation = true +rewrite.redundantBraces.methodBodies = true +rewrite.redundantBraces.generalExpressions = true +rewriteTokens = { + "⇒": "=>" + "→": "->" + "←": "<-" +} diff --git a/build.sbt b/build.sbt index 4bc3d686..bd196d59 100644 --- a/build.sbt +++ b/build.sbt @@ -32,17 +32,19 @@ lazy val commonSettings = Seq( Resolver.sonatypeRepo("snapshots") ), libraryDependencies ++= Seq( - "org.typelevel" %%% "cats-core" % catsVersion, - "org.typelevel" %%% "alleycats-core" % catsVersion, - "com.chuusai" %%% "shapeless" % shapelessVersion, - "org.typelevel" %%% "cats-testkit-scalatest" % testKitVersion % Test, - compilerPlugin("org.typelevel" %% "kind-projector" % "0.11.0" cross CrossVersion.full) + "org.typelevel" %%% "cats-core" % catsVersion, + "org.typelevel" %%% "alleycats-core" % catsVersion, + "com.chuusai" %%% "shapeless" % shapelessVersion, + "org.typelevel" %%% "cats-testkit-scalatest" % testKitVersion % Test, + compilerPlugin(("org.typelevel" %% "kind-projector" % "0.11.0").cross(CrossVersion.full)) ), scmInfo := - Some(ScmInfo( - url("https://github.com/typelevel/kittens"), - "scm:git:git@github.com:typelevel/kittens.git" - )), + Some( + ScmInfo( + url("https://github.com/typelevel/kittens"), + "scm:git:git@github.com:typelevel/kittens.git" + ) + ), testOptions += Tests.Argument("-oF"), mimaPreviousArtifacts := Set(organization.value %% moduleName.value % "2.0.0") ) ++ crossVersionSharedSources @@ -60,23 +62,24 @@ lazy val commonJvmSettings = Seq( lazy val coreSettings = buildSettings ++ commonSettings ++ publishSettings ++ releaseSettings -lazy val root = project.in(file(".")) +lazy val root = project + .in(file(".")) .aggregate(coreJS, coreJVM) .dependsOn(coreJS, coreJVM) - .settings(coreSettings:_*) + .settings(coreSettings: _*) .settings(noPublishSettings) -lazy val core = crossProject(JSPlatform, JVMPlatform).crossType(CrossType.Pure) +lazy val core = crossProject(JSPlatform, JVMPlatform) + .crossType(CrossType.Pure) .settings(moduleName := "kittens") - .settings(coreSettings:_*) - .jsSettings(commonJsSettings:_*) - .jvmSettings(commonJvmSettings:_*) - + .settings(coreSettings: _*) + .jsSettings(commonJsSettings: _*) + .jvmSettings(commonJvmSettings: _*) lazy val coreJVM = core.jvm lazy val coreJS = core.js -addCommandAlias("validate", ";root;clean;test;mima;doc") +addCommandAlias("validate", ";root;clean;scalafmtCheckAll;test;mima;doc") addCommandAlias("releaseAll", ";root;release") addCommandAlias("js", ";project coreJS") addCommandAlias("jvm", ";project coreJVM") @@ -86,8 +89,8 @@ addCommandAlias("mima", "coreJVM/mimaReportBinaryIssues") lazy val crossVersionSharedSources: Seq[Setting[_]] = Seq(Compile, Test).map { sc => (unmanagedSourceDirectories in sc) ++= { - (unmanagedSourceDirectories in sc ).value.map { - dir:File => new File(dir.getPath + "_" + scalaBinaryVersion.value) + (unmanagedSourceDirectories in sc).value.map { dir: File => + new File(dir.getPath + "_" + scalaBinaryVersion.value) } } } @@ -101,9 +104,9 @@ lazy val publishSettings = Seq( publishTo := { val nexus = "https://oss.sonatype.org/" if (version.value.trim.endsWith("SNAPSHOT")) - Some("snapshots" at nexus + "content/repositories/snapshots") + Some("snapshots".at(nexus + "content/repositories/snapshots")) else - Some("releases" at nexus + "service/local/staging/deploy/maven2") + Some("releases".at(nexus + "service/local/staging/deploy/maven2")) }, pomExtra := diff --git a/core/src/main/scala-2.12/cats/derived/semiauto.scala b/core/src/main/scala-2.12/cats/derived/semiauto.scala index fffb780f..84f3ec56 100644 --- a/core/src/main/scala-2.12/cats/derived/semiauto.scala +++ b/core/src/main/scala-2.12/cats/derived/semiauto.scala @@ -1,34 +1,33 @@ package cats.derived -/** - * allows semi automatically derive each instance. The derivation might need help when - * there are fields with a type constructor that comes with instances, e.g. - * {{{ - * scala> case class Bar(a: String) - * scala> case class Foo(bars: List[Bar]) - * scala> import cats.instances.all._ - * - * scala> cats.derived.semiauto.show[Foo].show(Foo(List(Bar("a")))) - * res1: String = Foo(bars = \$colon\$colon(head = Bar(a = a), tl\$access\$1 = Nil.type())) - * }}} - * Note that semi.show didn't respect the native `Show[List]` instance - * - * You could either derive a Bar instance first - * {{{ - * scala> implicit val barShow = cats.derived.semi.show[Bar] - * - * scala> cats.derived.semiauto.show[Foo].show(Foo(List(Bar("a")))) - * res2: String = Foo(bars = List(Bar(a = a))) - * }}} - * - * Or you can take advantage of a controlled auto derivation - * {{{ - * scala> implicit val fooShow: Show[Foo] = { | - * import cats.derived.auto.show._ | - * cats.derived.semiauto.show | - * } - * scala> Foo(List(Bar("a"))).show - * res3: String = Foo(bars = List(Bar(a = a))) - * }}} - */ +/** allows semi automatically derive each instance. The derivation might need help when + * there are fields with a type constructor that comes with instances, e.g. + * {{{ + * scala> case class Bar(a: String) + * scala> case class Foo(bars: List[Bar]) + * scala> import cats.instances.all._ + * + * scala> cats.derived.semiauto.show[Foo].show(Foo(List(Bar("a")))) + * res1: String = Foo(bars = \$colon\$colon(head = Bar(a = a), tl\$access\$1 = Nil.type())) + * }}} + * Note that semi.show didn't respect the native `Show[List]` instance + * + * You could either derive a Bar instance first + * {{{ + * scala> implicit val barShow = cats.derived.semi.show[Bar] + * + * scala> cats.derived.semiauto.show[Foo].show(Foo(List(Bar("a")))) + * res2: String = Foo(bars = List(Bar(a = a))) + * }}} + * + * Or you can take advantage of a controlled auto derivation + * {{{ + * scala> implicit val fooShow: Show[Foo] = { | + * import cats.derived.auto.show._ | + * cats.derived.semiauto.show | + * } + * scala> Foo(List(Bar("a"))).show + * res3: String = Foo(bars = List(Bar(a = a))) + * }}} + */ object semiauto extends SemiAutoInstances diff --git a/core/src/main/scala-2.12/cats/derived/util/versionspecific.scala b/core/src/main/scala-2.12/cats/derived/util/versionspecific.scala index 5945c47f..f5f12764 100644 --- a/core/src/main/scala-2.12/cats/derived/util/versionspecific.scala +++ b/core/src/main/scala-2.12/cats/derived/util/versionspecific.scala @@ -23,7 +23,7 @@ object VersionSpecific { implicit def primary[A, B](implicit a: A): A OrElse B = new Primary(a) } - private[util] abstract class OrElse0 { + abstract private[util] class OrElse0 { implicit def secondary[A, B](implicit b: Lazy[B]): A OrElse B = new Secondary(b.value) } } diff --git a/core/src/main/scala-2.13/cats/derived/semiauto.scala b/core/src/main/scala-2.13/cats/derived/semiauto.scala index 9a352c56..b096422b 100644 --- a/core/src/main/scala-2.13/cats/derived/semiauto.scala +++ b/core/src/main/scala-2.13/cats/derived/semiauto.scala @@ -4,37 +4,36 @@ package derived import alleycats.{ConsK, Empty, EmptyK, Pure} import cats.kernel.{CommutativeMonoid, CommutativeSemigroup} -/** - * allows semi automatically derive each instance. The derivation might need help when - * there are fields with a type constructor that comes with instances, e.g. - * {{{ - * scala> case class Bar(a: String) - * scala> case class Foo(bars: List[Bar]) - * scala> import cats.instances.all._ - * - * scala> cats.derived.semiauto.show[Foo].show(Foo(List(Bar("a")))) - * res1: String = Foo(bars = \$colon\$colon(head = Bar(a = a), tl\$access\$1 = Nil.type())) - * }}} - * Note that semi.show didn't respect the native `Show[List]` instance - * - * You could either derive a Bar instance first - * {{{ - * scala> implicit val barShow = cats.derived.semi.show[Bar] - * - * scala> cats.derived.semiauto.show[Foo].show(Foo(List(Bar("a")))) - * res2: String = Foo(bars = List(Bar(a = a))) - * }}} - * - * Or you can take advantage of a controlled auto derivation - * {{{ - * scala> implicit val fooShow: Show[Foo] = { | - * import cats.derived.auto.show._ | - * cats.derived.semiauto.show | - * } - * scala> Foo(List(Bar("a"))).show - * res3: String = Foo(bars = List(Bar(a = a))) - * }}} - */ +/** allows semi automatically derive each instance. The derivation might need help when + * there are fields with a type constructor that comes with instances, e.g. + * {{{ + * scala> case class Bar(a: String) + * scala> case class Foo(bars: List[Bar]) + * scala> import cats.instances.all._ + * + * scala> cats.derived.semiauto.show[Foo].show(Foo(List(Bar("a")))) + * res1: String = Foo(bars = \$colon\$colon(head = Bar(a = a), tl\$access\$1 = Nil.type())) + * }}} + * Note that semi.show didn't respect the native `Show[List]` instance + * + * You could either derive a Bar instance first + * {{{ + * scala> implicit val barShow = cats.derived.semi.show[Bar] + * + * scala> cats.derived.semiauto.show[Foo].show(Foo(List(Bar("a")))) + * res2: String = Foo(bars = List(Bar(a = a))) + * }}} + * + * Or you can take advantage of a controlled auto derivation + * {{{ + * scala> implicit val fooShow: Show[Foo] = { | + * import cats.derived.auto.show._ | + * cats.derived.semiauto.show | + * } + * scala> Foo(List(Bar("a"))).show + * res3: String = Foo(bars = List(Bar(a = a))) + * }}} + */ object semiauto { def eq[A](implicit ev: MkEq[A]): Eq[A] = ev diff --git a/core/src/main/scala-2.13/cats/derived/util/versionspecific.scala b/core/src/main/scala-2.13/cats/derived/util/versionspecific.scala index d350f65f..71a921e5 100644 --- a/core/src/main/scala-2.13/cats/derived/util/versionspecific.scala +++ b/core/src/main/scala-2.13/cats/derived/util/versionspecific.scala @@ -36,7 +36,7 @@ object VersionSpecific { implicit def primary[A, B](implicit a: A): A OrElse B = new Primary(a) } - private[util] abstract class OrElse0 { + abstract private[util] class OrElse0 { implicit def secondary[A, B](implicit b: => B): A OrElse B = new Secondary(b) } } diff --git a/core/src/main/scala/cats/derived/applicative.scala b/core/src/main/scala/cats/derived/applicative.scala index 97ef1593..a57e940c 100644 --- a/core/src/main/scala/cats/derived/applicative.scala +++ b/core/src/main/scala/cats/derived/applicative.scala @@ -35,7 +35,7 @@ object MkApplicative extends MkApplicativeDerivation { def apply[F[_]](implicit F: MkApplicative[F]): MkApplicative[F] = F } -private[derived] abstract class MkApplicativeDerivation extends MkApplicativeNested { +abstract private[derived] class MkApplicativeDerivation extends MkApplicativeNested { implicit val mkApplicativeHNil: MkApplicative[Const[HNil]#λ] = new MkApplicative[Const[HNil]#λ] { def pure[A](x: A) = HNil @@ -51,7 +51,7 @@ private[derived] abstract class MkApplicativeDerivation extends MkApplicativeNes } } -private[derived] abstract class MkApplicativeNested extends MkApplicativeGeneric { +abstract private[derived] class MkApplicativeNested extends MkApplicativeGeneric { implicit def mkApplicativeNested[F[_]](implicit F: Split1[F, ApplicativeOrMk, ApplicativeOrMk]): MkApplicative[F] = new MkApplicative[F] { @@ -69,7 +69,7 @@ private[derived] abstract class MkApplicativeNested extends MkApplicativeGeneric } } -private[derived] abstract class MkApplicativeGeneric { +abstract private[derived] class MkApplicativeGeneric { protected type ApplicativeOrMk[F[_]] = Applicative[F] OrElse MkApplicative[F] implicit def mkApplicativeHCons[F[_]](implicit F: IsHCons1[F, ApplicativeOrMk, MkApplicative]): MkApplicative[F] = diff --git a/core/src/main/scala/cats/derived/apply.scala b/core/src/main/scala/cats/derived/apply.scala index 24d1e239..2ea5ed65 100644 --- a/core/src/main/scala/cats/derived/apply.scala +++ b/core/src/main/scala/cats/derived/apply.scala @@ -35,7 +35,7 @@ object MkApply extends MkApplyDerivation { def apply[F[_]](implicit F: MkApply[F]): MkApply[F] = F } -private[derived] abstract class MkApplyDerivation extends MkApplyNested { +abstract private[derived] class MkApplyDerivation extends MkApplyNested { implicit val mkApplyHNil: MkApply[Const[HNil]#λ] = new MkApply[Const[HNil]#λ] { def ap[A, B](ff: HNil)(fa: HNil) = ff @@ -49,7 +49,7 @@ private[derived] abstract class MkApplyDerivation extends MkApplyNested { } } -private[derived] abstract class MkApplyNested extends MkApplyGeneric { +abstract private[derived] class MkApplyNested extends MkApplyGeneric { implicit def mkApplyNested[F[_]](implicit F: Split1[F, ApplyOrMk, ApplyOrMk]): MkApply[F] = new MkApply[F] { @@ -64,7 +64,7 @@ private[derived] abstract class MkApplyNested extends MkApplyGeneric { } } -private[derived] abstract class MkApplyGeneric { +abstract private[derived] class MkApplyGeneric { protected type ApplyOrMk[F[_]] = Apply[F] OrElse MkApply[F] implicit def mkApplyHCons[F[_]](implicit F: IsHCons1[F, ApplyOrMk, MkApply]): MkApply[F] = diff --git a/core/src/main/scala/cats/derived/commutativeMonoid.scala b/core/src/main/scala/cats/derived/commutativeMonoid.scala index 7433f18c..ce7f6c81 100644 --- a/core/src/main/scala/cats/derived/commutativeMonoid.scala +++ b/core/src/main/scala/cats/derived/commutativeMonoid.scala @@ -30,19 +30,22 @@ object MkCommutativeMonoid extends MkCommutativeMonoidDerivation { def apply[A](implicit ev: MkCommutativeMonoid[A]): MkCommutativeMonoid[A] = ev } -private[derived] abstract class MkCommutativeMonoidDerivation { +abstract private[derived] class MkCommutativeMonoidDerivation { implicit val mkCommutativeMonoidHNil: MkCommutativeMonoid[HNil] = instance[HNil](HNil)((_, _) => HNil) - implicit def mkCommutativeMonoidHCons[H, T <: HList]( - implicit H: CommutativeMonoid[H] OrElse MkCommutativeMonoid[H], T: MkCommutativeMonoid[T] - ): MkCommutativeMonoid[H :: T] = instance(H.unify.empty :: T.empty) { - case (hx :: tx, hy :: ty) => H.unify.combine(hx, hy) :: T.combine(tx, ty) + implicit def mkCommutativeMonoidHCons[H, T <: HList](implicit + H: CommutativeMonoid[H] OrElse MkCommutativeMonoid[H], + T: MkCommutativeMonoid[T] + ): MkCommutativeMonoid[H :: T] = instance(H.unify.empty :: T.empty) { case (hx :: tx, hy :: ty) => + H.unify.combine(hx, hy) :: T.combine(tx, ty) } - - implicit def mkCommutativeMonoidGeneric[A, R](implicit A: Generic.Aux[A, R], R: Lazy[MkCommutativeMonoid[R]]): MkCommutativeMonoid[A] = + implicit def mkCommutativeMonoidGeneric[A, R](implicit + A: Generic.Aux[A, R], + R: Lazy[MkCommutativeMonoid[R]] + ): MkCommutativeMonoid[A] = new MkCommutativeMonoid[A] { // Cache empty case classes. lazy val empty = A.from(R.value.empty) diff --git a/core/src/main/scala/cats/derived/commutativeSemigroup.scala b/core/src/main/scala/cats/derived/commutativeSemigroup.scala index 492affb1..488eb1b9 100644 --- a/core/src/main/scala/cats/derived/commutativeSemigroup.scala +++ b/core/src/main/scala/cats/derived/commutativeSemigroup.scala @@ -30,18 +30,22 @@ object MkCommutativeSemigroup extends MkCommutativeSemigroupDerivation { def apply[A](implicit ev: MkCommutativeSemigroup[A]): MkCommutativeSemigroup[A] = ev } -private[derived] abstract class MkCommutativeSemigroupDerivation { +abstract private[derived] class MkCommutativeSemigroupDerivation { implicit val mkCommutativeSemigroupHNil: MkCommutativeSemigroup[HNil] = instance((_, _) => HNil) - implicit def mkCommutativeSemigroupHCons[H, T <: HList]( - implicit H: CommutativeSemigroup[H] OrElse MkCommutativeSemigroup[H], T: MkCommutativeSemigroup[T] + implicit def mkCommutativeSemigroupHCons[H, T <: HList](implicit + H: CommutativeSemigroup[H] OrElse MkCommutativeSemigroup[H], + T: MkCommutativeSemigroup[T] ): MkCommutativeSemigroup[H :: T] = instance { case (hx :: tx, hy :: ty) => H.unify.combine(hx, hy) :: T.combine(tx, ty) } - implicit def mkCommutativeSemigroupGeneric[A, R](implicit A: Generic.Aux[A, R], R: Lazy[MkCommutativeSemigroup[R]]): MkCommutativeSemigroup[A] = + implicit def mkCommutativeSemigroupGeneric[A, R](implicit + A: Generic.Aux[A, R], + R: Lazy[MkCommutativeSemigroup[R]] + ): MkCommutativeSemigroup[A] = instance((x, y) => A.from(R.value.combine(A.to(x), A.to(y)))) private def instance[A](f: (A, A) => A): MkCommutativeSemigroup[A] = @@ -49,4 +53,3 @@ private[derived] abstract class MkCommutativeSemigroupDerivation { def combine(x: A, y: A) = f(x, y) } } - diff --git a/core/src/main/scala/cats/derived/consk.scala b/core/src/main/scala/cats/derived/consk.scala index 555b587e..f1431a3f 100644 --- a/core/src/main/scala/cats/derived/consk.scala +++ b/core/src/main/scala/cats/derived/consk.scala @@ -35,7 +35,7 @@ object MkConsK extends MkConsKDerivation { } } -private[derived] abstract class MkConsKDerivation extends MkConsKRight { +abstract private[derived] class MkConsKDerivation extends MkConsKRight { implicit def mkConsKHConsLeft[G[_]]: MkConsK[λ[t => t :: G[t] :: HNil], G] = new MkConsK[λ[t => t :: G[t] :: HNil], G] { @@ -43,12 +43,12 @@ private[derived] abstract class MkConsKDerivation extends MkConsKRight { } implicit def mkConsKCConsLeft[F[_], G[_]](implicit F: IsCCons1[F, MkConsK[*[_], G], Trivial1]): MkConsK[F, G] = - new MkConsK[F, G] { - def cons[A](head: A, tail: G[A]) = F.pack(Left(F.fh.cons(head, tail))) - } + new MkConsK[F, G] { + def cons[A](head: A, tail: G[A]) = F.pack(Left(F.fh.cons(head, tail))) + } } -private[derived] abstract class MkConsKRight extends MkConsKGeneric { +abstract private[derived] class MkConsKRight extends MkConsKGeneric { implicit def mkConsKHConsRight[G[_]]: MkConsK[λ[t => G[t] :: t :: HNil], G] = new MkConsK[λ[t => G[t] :: t :: HNil], G] { @@ -61,7 +61,7 @@ private[derived] abstract class MkConsKRight extends MkConsKGeneric { } } -private[derived] abstract class MkConsKGeneric { +abstract private[derived] class MkConsKGeneric { implicit def mkConsKGeneric[F[_], G[_]](implicit F: Generic1[F, MkConsK[*[_], G]]): MkConsK[F, G] = new MkConsK[F, G] { diff --git a/core/src/main/scala/cats/derived/contravariant.scala b/core/src/main/scala/cats/derived/contravariant.scala index 17d0ebe4..ceb60060 100644 --- a/core/src/main/scala/cats/derived/contravariant.scala +++ b/core/src/main/scala/cats/derived/contravariant.scala @@ -39,7 +39,7 @@ object MkContravariant extends MkContravariantDerivation { def apply[F[_]](implicit F: MkContravariant[F]): MkContravariant[F] = F } -private[derived] abstract class MkContravariantDerivation extends MkFunctorContraNested { +abstract private[derived] class MkContravariantDerivation extends MkFunctorContraNested { implicit val mkContraHNil: MkContravariant[Const[HNil]#λ] = mkContraConst implicit val mkContraCNil: MkContravariant[Const[CNil]#λ] = mkContraConst @@ -49,7 +49,7 @@ private[derived] abstract class MkContravariantDerivation extends MkFunctorContr } } -private[derived] abstract class MkFunctorContraNested extends MkContravariantCons { +abstract private[derived] class MkFunctorContraNested extends MkContravariantCons { implicit def mkFunctorContraNested[F[_]](implicit F: Split1[F, Functor, ContraOrMk]): MkContravariant[F] = new MkContravariant[F] { @@ -59,7 +59,7 @@ private[derived] abstract class MkFunctorContraNested extends MkContravariantCon } } -private[derived] abstract class MkContravariantCons extends MkContravariantGeneric { +abstract private[derived] class MkContravariantCons extends MkContravariantGeneric { implicit def mkContraHCons[F[_]](implicit F: IsHCons1[F, ContraOrMk, MkContravariant]): MkContravariant[F] = new MkContravariant[F] { @@ -83,7 +83,7 @@ private[derived] abstract class MkContravariantCons extends MkContravariantGener } } -private[derived] abstract class MkContravariantGeneric { +abstract private[derived] class MkContravariantGeneric { protected type ContraOrMk[F[_]] = Contravariant[F] OrElse MkContravariant[F] protected def mkContraSafe[F[_], A, B](F: ContraOrMk[F])(fa: F[B])(f: A => Eval[B]): Eval[F[A]] = @@ -99,4 +99,3 @@ private[derived] abstract class MkContravariantGeneric { F.fr.safeContramap(F.to(fa))(f).map(F.from) } } - diff --git a/core/src/main/scala/cats/derived/empty.scala b/core/src/main/scala/cats/derived/empty.scala index 0789698b..32245d85 100644 --- a/core/src/main/scala/cats/derived/empty.scala +++ b/core/src/main/scala/cats/derived/empty.scala @@ -33,7 +33,7 @@ object MkEmpty extends MkEmptyDerivation { def apply[A](implicit ev: MkEmpty[A]): MkEmpty[A] = ev } -private[derived] abstract class MkEmptyDerivation { +abstract private[derived] class MkEmptyDerivation { protected type EmptyOrMk[A] = Empty[A] OrElse MkEmpty[A] implicit val mkEmptyHNil: MkEmpty[HNil] = @@ -42,10 +42,10 @@ private[derived] abstract class MkEmptyDerivation { implicit def mkEmptyHCons[H, T <: HList](implicit H: EmptyOrMk[H], T: MkEmpty[T]): MkEmpty[H :: T] = instance(H.unify.empty :: T.empty) - implicit def mkEmptyCoproduct[C <: Coproduct, E <: HList, A]( - implicit lift: util.LiftSome.Aux[EmptyOrMk, C, E], - unique: E <:< (EmptyOrMk[A] :: HNil), - inject: ops.coproduct.Inject[C, A] + implicit def mkEmptyCoproduct[C <: Coproduct, E <: HList, A](implicit + lift: util.LiftSome.Aux[EmptyOrMk, C, E], + unique: E <:< (EmptyOrMk[A] :: HNil), + inject: ops.coproduct.Inject[C, A] ): MkEmpty[C] = instance(inject(lift.instances.head.unify.empty)) implicit def mkEmptyGeneric[A, R](implicit A: Generic.Aux[A, R], R: Lazy[MkEmpty[R]]): MkEmpty[A] = diff --git a/core/src/main/scala/cats/derived/emptyk.scala b/core/src/main/scala/cats/derived/emptyk.scala index 97aa5624..5a8d7c01 100644 --- a/core/src/main/scala/cats/derived/emptyk.scala +++ b/core/src/main/scala/cats/derived/emptyk.scala @@ -36,7 +36,7 @@ object MkEmptyK extends MkEmptyKDerivation { def apply[F[_]](implicit F: MkEmptyK[F]): MkEmptyK[F] = F } -private[derived] abstract class MkEmptyKDerivation extends MkEmptyKNestedOuter { +abstract private[derived] class MkEmptyKDerivation extends MkEmptyKNestedOuter { implicit val mkEmptyKHNil: MkEmptyK[Const[HNil]#λ] = new MkEmptyK[Const[HNil]#λ] { @@ -49,7 +49,7 @@ private[derived] abstract class MkEmptyKDerivation extends MkEmptyKNestedOuter { } } -private[derived] abstract class MkEmptyKNestedOuter extends MkEmptyKNestedInner { +abstract private[derived] class MkEmptyKNestedOuter extends MkEmptyKNestedInner { implicit def mkEmptyKNestedOuter[F[_]](implicit F: Split1[F, EmptyKOrMk, Trivial1]): MkEmptyK[F] = new MkEmptyK[F] { @@ -57,7 +57,7 @@ private[derived] abstract class MkEmptyKNestedOuter extends MkEmptyKNestedInner } } -private[derived] abstract class MkEmptyKNestedInner extends MkEmptyKCons { +abstract private[derived] class MkEmptyKNestedInner extends MkEmptyKCons { implicit def mkEmptyKNestedInner[F[_]](implicit F: Split1[F, Pure, EmptyKOrMk]): MkEmptyK[F] = new MkEmptyK[F] { @@ -65,7 +65,7 @@ private[derived] abstract class MkEmptyKNestedInner extends MkEmptyKCons { } } -private[derived] abstract class MkEmptyKCons extends MkEmptyKGeneric { +abstract private[derived] class MkEmptyKCons extends MkEmptyKGeneric { implicit def mkEmptyKHCons[F[_]](implicit F: IsHCons1[F, EmptyKOrMk, MkEmptyK]): MkEmptyK[F] = new MkEmptyK[F] { @@ -73,7 +73,7 @@ private[derived] abstract class MkEmptyKCons extends MkEmptyKGeneric { } } -private[derived] abstract class MkEmptyKGeneric { +abstract private[derived] class MkEmptyKGeneric { protected type EmptyKOrMk[F[_]] = EmptyK[F] OrElse MkEmptyK[F] implicit def mkEmptyKGeneric[F[_]](implicit F: Generic1[F, MkEmptyK]): MkEmptyK[F] = diff --git a/core/src/main/scala/cats/derived/eq.scala b/core/src/main/scala/cats/derived/eq.scala index 89b24a06..1978736f 100644 --- a/core/src/main/scala/cats/derived/eq.scala +++ b/core/src/main/scala/cats/derived/eq.scala @@ -32,7 +32,7 @@ object MkEq extends MkEqDerivation { def apply[A](implicit ev: MkEq[A]): MkEq[A] = ev } -private[derived] abstract class MkEqDerivation { +abstract private[derived] class MkEqDerivation { implicit val mkEqHNil: MkEq[HNil] = instance((_, _) => true) implicit val mkEqCNil: MkEq[CNil] = instance((_, _) => true) diff --git a/core/src/main/scala/cats/derived/foldable.scala b/core/src/main/scala/cats/derived/foldable.scala index 25f6d820..2d06b6d3 100644 --- a/core/src/main/scala/cats/derived/foldable.scala +++ b/core/src/main/scala/cats/derived/foldable.scala @@ -42,7 +42,7 @@ object MkFoldable extends MkFoldableDerivation { def apply[F[_]](implicit F: MkFoldable[F]): MkFoldable[F] = F } -private[derived] abstract class MkFoldableDerivation extends MkFoldableNested { +abstract private[derived] class MkFoldableDerivation extends MkFoldableNested { implicit val mkFoldableHNil: MkFoldable[Const[HNil]#λ] = mkFoldableConst implicit val mkFoldableCNil: MkFoldable[Const[CNil]#λ] = mkFoldableConst @@ -53,7 +53,7 @@ private[derived] abstract class MkFoldableDerivation extends MkFoldableNested { } } -private[derived] abstract class MkFoldableNested extends MkFoldableCons { +abstract private[derived] class MkFoldableNested extends MkFoldableCons { implicit def mkFoldableNested[F[_]](implicit F: Split1[F, FoldableOrMk, FoldableOrMk]): MkFoldable[F] = new MkFoldable[F] { @@ -66,7 +66,7 @@ private[derived] abstract class MkFoldableNested extends MkFoldableCons { } } -private[derived] abstract class MkFoldableCons extends MkFoldableGeneric { +abstract private[derived] class MkFoldableCons extends MkFoldableGeneric { implicit def mkFoldableHCons[F[_]](implicit F: IsHCons1[F, FoldableOrMk, MkFoldable]): MkFoldable[F] = new MkFoldable[F] { @@ -99,7 +99,7 @@ private[derived] abstract class MkFoldableCons extends MkFoldableGeneric { } } -private[derived] abstract class MkFoldableGeneric { +abstract private[derived] class MkFoldableGeneric { protected type FoldableOrMk[F[_]] = Foldable[F] OrElse MkFoldable[F] private[derived] def mkSafeFoldLeft[F[_], A, B](F: FoldableOrMk[F])(fa: F[A], b: B)(f: (B, A) => Eval[B]): Eval[B] = diff --git a/core/src/main/scala/cats/derived/function.scala b/core/src/main/scala/cats/derived/function.scala index 4e86dd38..9dfb36ae 100644 --- a/core/src/main/scala/cats/derived/function.scala +++ b/core/src/main/scala/cats/derived/function.scala @@ -6,8 +6,8 @@ import shapeless._ object function extends FunctionInstances { - implicit def kittensMkMonadForFunctionN[F[_], L <: _ :: _ :: _]( - implicit gen: FnGeneric.Aux[F, L] + implicit def kittensMkMonadForFunctionN[F[_], L <: _ :: _ :: _](implicit + gen: FnGeneric.Aux[F, L] ): Monad[F] = new Monad[F] { private[this] val F = Monad[L => *] @@ -25,10 +25,10 @@ object function extends FunctionInstances { } } -private[derived] abstract class FunctionInstances { +abstract private[derived] class FunctionInstances { - implicit def kittensMkDistributiveForFunctionN[F[_], L <: _ :: _ :: _]( - implicit gen: FnGeneric.Aux[F, L] + implicit def kittensMkDistributiveForFunctionN[F[_], L <: _ :: _ :: _](implicit + gen: FnGeneric.Aux[F, L] ): Distributive[F] = new Distributive[F] { private[this] val F = Distributive[L => *] diff --git a/core/src/main/scala/cats/derived/functor.scala b/core/src/main/scala/cats/derived/functor.scala index d0a82fd7..71013e60 100644 --- a/core/src/main/scala/cats/derived/functor.scala +++ b/core/src/main/scala/cats/derived/functor.scala @@ -42,7 +42,7 @@ object MkFunctor extends MkFunctorDerivation { def apply[F[_]](implicit F: MkFunctor[F]): MkFunctor[F] = F } -private[derived] abstract class MkFunctorDerivation extends MkFunctorNested { +abstract private[derived] class MkFunctorDerivation extends MkFunctorNested { implicit val mkFunctorHNil: MkFunctor[Const[HNil]#λ] = mkFunctorConst implicit val mkFunctorCNil: MkFunctor[Const[CNil]#λ] = mkFunctorConst @@ -52,7 +52,7 @@ private[derived] abstract class MkFunctorDerivation extends MkFunctorNested { } } -private[derived] abstract class MkFunctorNested extends MkFunctorNestedContra { +abstract private[derived] class MkFunctorNested extends MkFunctorNestedContra { implicit def mkFunctorNested[F[_]](implicit F: Split1[F, FunctorOrMk, FunctorOrMk]): MkFunctor[F] = new MkFunctor[F] { @@ -62,7 +62,7 @@ private[derived] abstract class MkFunctorNested extends MkFunctorNestedContra { } } -private[derived] abstract class MkFunctorNestedContra extends MkFunctorCons { +abstract private[derived] class MkFunctorNestedContra extends MkFunctorCons { implicit def mkFunctorNestedContra[F[_]](implicit F: Split1[F, Contravariant, Contravariant]): MkFunctor[F] = new MkFunctor[F] { @@ -72,7 +72,7 @@ private[derived] abstract class MkFunctorNestedContra extends MkFunctorCons { } } -private[derived] abstract class MkFunctorCons extends MkFunctorGeneric { +abstract private[derived] class MkFunctorCons extends MkFunctorGeneric { implicit def mkFunctorHCons[F[_]](implicit F: IsHCons1[F, FunctorOrMk, MkFunctor]): MkFunctor[F] = new MkFunctor[F] { @@ -96,7 +96,7 @@ private[derived] abstract class MkFunctorCons extends MkFunctorGeneric { } } -private[derived] abstract class MkFunctorGeneric { +abstract private[derived] class MkFunctorGeneric { protected type FunctorOrMk[F[_]] = Functor[F] OrElse MkFunctor[F] protected def mkSafeMap[F[_], A, B](F: FunctorOrMk[F])(fa: F[A])(f: A => Eval[B]): Eval[F[B]] = diff --git a/core/src/main/scala/cats/derived/hash.scala b/core/src/main/scala/cats/derived/hash.scala index 617ef366..7750ef24 100644 --- a/core/src/main/scala/cats/derived/hash.scala +++ b/core/src/main/scala/cats/derived/hash.scala @@ -36,8 +36,9 @@ private[derived] object HashBuilder { implicit val hashBuilderHNil: HashBuilder[HNil] = instance(_ => Nil, (_, _) => true) - implicit def hashBuilderHCons[H, T <: HList]( - implicit H: Hash[H] OrElse MkHash[H], T: HashBuilder[T] + implicit def hashBuilderHCons[H, T <: HList](implicit + H: Hash[H] OrElse MkHash[H], + T: HashBuilder[T] ): HashBuilder[H :: T] = instance( { case h :: t => H.unify.hash(h) :: T.hashes(t) }, { case (hx :: tx, hy :: ty) => H.unify.eqv(hx, hy) && T.eqv(tx, ty) } @@ -50,50 +51,58 @@ private[derived] object HashBuilder { } } -private[derived] abstract class MkHashDerivation extends MkHashGenericProduct { +abstract private[derived] class MkHashDerivation extends MkHashGenericProduct { implicit val mkHashCNil: MkHash[CNil] = instance(_ => 0, (_, _) => true) - implicit def mkHashCCons[L, R <: Coproduct]( - implicit L: Hash[L] OrElse MkHash[L], R: MkHash[R] - ): MkHash[L :+: R] = instance({ - case Inl(l) => L.unify.hash(l) - case Inr(r) => R.hash(r) - }, { - case (Inl(lx), Inl(ly)) => L.unify.eqv(lx, ly) - case (Inr(rx), Inr(ry)) => R.eqv(rx, ry) - case _ => false - }) + implicit def mkHashCCons[L, R <: Coproduct](implicit + L: Hash[L] OrElse MkHash[L], + R: MkHash[R] + ): MkHash[L :+: R] = instance( + { + case Inl(l) => L.unify.hash(l) + case Inr(r) => R.hash(r) + }, + { + case (Inl(lx), Inl(ly)) => L.unify.eqv(lx, ly) + case (Inr(rx), Inr(ry)) => R.eqv(rx, ry) + case _ => false + } + ) implicit def mkHashCaseObject[A](implicit A: Generic.Aux[A, HNil]): MkHash[A] = instance(_.hashCode, (_, _) => true) } -private[derived] abstract class MkHashGenericProduct extends MkHashGenericHList { +abstract private[derived] class MkHashGenericProduct extends MkHashGenericHList { - implicit def mkHashGenericProduct[A, R <: HList]( - implicit A: Generic.Aux[A, R], R: Lazy[HashBuilder[R]], ev: A <:< Product + implicit def mkHashGenericProduct[A, R <: HList](implicit + A: Generic.Aux[A, R], + R: Lazy[HashBuilder[R]], + ev: A <:< Product ): MkHash[A] = instance( x => R.value.hash(A.to(x), util.VersionSpecific.productSeed(x)), (x, y) => R.value.eqv(A.to(x), A.to(y)) ) } -private[derived] abstract class MkHashGenericHList extends MkHashGenericCoproduct { +abstract private[derived] class MkHashGenericHList extends MkHashGenericCoproduct { - implicit def mkHashGenericHList[A, R <: HList]( - implicit A: Generic.Aux[A, R], R: Lazy[HashBuilder[R]] + implicit def mkHashGenericHList[A, R <: HList](implicit + A: Generic.Aux[A, R], + R: Lazy[HashBuilder[R]] ): MkHash[A] = instance( x => R.value.hash(A.to(x), MurmurHash3.productSeed), (x, y) => R.value.eqv(A.to(x), A.to(y)) ) } -private[derived] abstract class MkHashGenericCoproduct { +abstract private[derived] class MkHashGenericCoproduct { - implicit def mkHashGenericCoproduct[A, R <: Coproduct]( - implicit A: Generic.Aux[A, R], R: Lazy[MkHash[R]] + implicit def mkHashGenericCoproduct[A, R <: Coproduct](implicit + A: Generic.Aux[A, R], + R: Lazy[MkHash[R]] ): MkHash[A] = instance( x => R.value.hash(A.to(x)), (x, y) => R.value.eqv(A.to(x), A.to(y)) diff --git a/core/src/main/scala/cats/derived/invariant.scala b/core/src/main/scala/cats/derived/invariant.scala index 61ccc5dc..43d3b71a 100644 --- a/core/src/main/scala/cats/derived/invariant.scala +++ b/core/src/main/scala/cats/derived/invariant.scala @@ -38,7 +38,7 @@ trait MkInvariant[F[_]] extends Invariant[F] { object MkInvariant extends MkInvariantDerivation { def apply[F[_]](implicit F: MkInvariant[F]): MkInvariant[F] = F } -private[derived] abstract class MkInvariantDerivation extends MkInvariantNested { +abstract private[derived] class MkInvariantDerivation extends MkInvariantNested { implicit val mkInvariantHNil: MkInvariant[Const[HNil]#λ] = mkInvariantConst implicit val mkInvariantCNil: MkInvariant[Const[CNil]#λ] = mkInvariantConst @@ -48,18 +48,17 @@ private[derived] abstract class MkInvariantDerivation extends MkInvariantNested } } -private[derived] abstract class MkInvariantNested extends MkInvariantCons { +abstract private[derived] class MkInvariantNested extends MkInvariantCons { implicit def mkFunctorInvariantNested[F[_]](implicit F: Split1[F, InvariantOrMk, InvariantOrMk]): MkInvariant[F] = new MkInvariant[F] { def safeImap[A, B](fa: F[A])(g: A => Eval[B])(f: B => Eval[A]): Eval[F[B]] = - mkImapSafe[F.O, F.I[B], F.I[A]](F.fo)(F.unpack(fa))( - mkImapSafe(F.fi)(_)(g)(f))( + mkImapSafe[F.O, F.I[B], F.I[A]](F.fo)(F.unpack(fa))(mkImapSafe(F.fi)(_)(g)(f))( mkImapSafe(F.fi)(_)(f)(g) ).map(F.pack) } } -private[derived] abstract class MkInvariantCons extends MkInvariantGeneric { +abstract private[derived] class MkInvariantCons extends MkInvariantGeneric { implicit def mkInvariantHCons[F[_]](implicit F: IsHCons1[F, InvariantOrMk, MkInvariant]): MkInvariant[F] = new MkInvariant[F] { def safeImap[A, B](fa: F[A])(g: A => Eval[B])(f: B => Eval[A]): Eval[F[B]] = @@ -79,7 +78,7 @@ private[derived] abstract class MkInvariantCons extends MkInvariantGeneric { } } } -private[derived] abstract class MkInvariantGeneric { +abstract private[derived] class MkInvariantGeneric { protected type InvariantOrMk[F[_]] = Invariant[F] OrElse MkInvariant[F] protected def mkImapSafe[F[_], A, B](F: InvariantOrMk[F])(fa: F[B])(g: B => Eval[A])(f: A => Eval[B]): Eval[F[A]] = @@ -94,4 +93,3 @@ private[derived] abstract class MkInvariantGeneric { F.fr.safeImap(F.to(fa))(g)(f).map(F.from[B]) } } - diff --git a/core/src/main/scala/cats/derived/iterable.scala b/core/src/main/scala/cats/derived/iterable.scala index 5cef1838..f6d2bdac 100644 --- a/core/src/main/scala/cats/derived/iterable.scala +++ b/core/src/main/scala/cats/derived/iterable.scala @@ -51,13 +51,14 @@ trait MkIterable[F[_]] { def next(): A = if (!hasNext) Iterator.empty.next() - else (first: @unchecked) match { - case IterState.Return(a) => - first = IterState.Done - a - case IterState.Iterate(it) => - it.next() - } + else + (first: @unchecked) match { + case IterState.Return(a) => + first = IterState.Done + a + case IterState.Iterate(it) => + it.next() + } } } } @@ -74,7 +75,7 @@ object MkIterable extends MkIterableDerivation { def apply[F[_]](implicit F: MkIterable[F]): MkIterable[F] = F } -private[derived] abstract class MkIterableDerivation extends MkIterableNested { +abstract private[derived] class MkIterableDerivation extends MkIterableNested { implicit val mkIterableHNil: MkIterable[Const[HNil]#λ] = mkIterableConst implicit val mkIterableCNil: MkIterable[Const[CNil]#λ] = mkIterableConst @@ -99,7 +100,7 @@ private[derived] abstract class MkIterableDerivation extends MkIterableNested { } } -private[derived] abstract class MkIterableNested extends MkIterableGeneric { +abstract private[derived] class MkIterableNested extends MkIterableGeneric { implicit def mkIterableNested[F[_]](implicit F: Split1[F, MkIterable, MkIterable]): MkIterable[F] = new MkIterable[F] { @@ -109,7 +110,7 @@ private[derived] abstract class MkIterableNested extends MkIterableGeneric { } } -private[derived] abstract class MkIterableGeneric { +abstract private[derived] class MkIterableGeneric { implicit def mkIterableHCons[F[_]](implicit F: IsHCons1[F, MkIterable, MkIterable]): MkIterable[F] = new MkIterable[F] { diff --git a/core/src/main/scala/cats/derived/monoid.scala b/core/src/main/scala/cats/derived/monoid.scala index 352c3ac9..c412c402 100644 --- a/core/src/main/scala/cats/derived/monoid.scala +++ b/core/src/main/scala/cats/derived/monoid.scala @@ -30,18 +30,18 @@ object MkMonoid extends MkMonoidDerivation { def apply[A](implicit ev: MkMonoid[A]): MkMonoid[A] = ev } -private[derived] abstract class MkMonoidDerivation { +abstract private[derived] class MkMonoidDerivation { implicit val mkMonoidHNil: MkMonoid[HNil] = instance[HNil](HNil)((_, _) => HNil) - implicit def mkMonoidHCons[H, T <: HList]( - implicit H: Monoid[H] OrElse MkMonoid[H], T: MkMonoid[T] - ): MkMonoid[H :: T] = instance(H.unify.empty :: T.empty) { - case (hx :: tx, hy :: ty) => H.unify.combine(hx, hy) :: T.combine(tx, ty) + implicit def mkMonoidHCons[H, T <: HList](implicit + H: Monoid[H] OrElse MkMonoid[H], + T: MkMonoid[T] + ): MkMonoid[H :: T] = instance(H.unify.empty :: T.empty) { case (hx :: tx, hy :: ty) => + H.unify.combine(hx, hy) :: T.combine(tx, ty) } - implicit def mkMonoidGeneric[A, R](implicit A: Generic.Aux[A, R], R: Lazy[MkMonoid[R]]): MkMonoid[A] = new MkMonoid[A] { // Cache empty case classes. diff --git a/core/src/main/scala/cats/derived/monoidk.scala b/core/src/main/scala/cats/derived/monoidk.scala index 0cc380a9..31a76687 100644 --- a/core/src/main/scala/cats/derived/monoidk.scala +++ b/core/src/main/scala/cats/derived/monoidk.scala @@ -36,7 +36,7 @@ object MkMonoidK extends MkMonoidKDerivation { def apply[F[_]](implicit F: MkMonoidK[F]): MkMonoidK[F] = F } -private[derived] abstract class MkMonoidKDerivation extends MkMonoidKNestedOuter { +abstract private[derived] class MkMonoidKDerivation extends MkMonoidKNestedOuter { implicit val mkMonoidKHNil: MkMonoidK[Const[HNil]#λ] = new MkMonoidK[Const[HNil]#λ] { @@ -51,7 +51,7 @@ private[derived] abstract class MkMonoidKDerivation extends MkMonoidKNestedOuter } } -private[derived] abstract class MkMonoidKNestedOuter extends MkMonoidKNestedInner { +abstract private[derived] class MkMonoidKNestedOuter extends MkMonoidKNestedInner { implicit def mkMonoidKNestedOuter[F[_]](implicit F: Split1[F, MonoidKOrMk, Trivial1]): MkMonoidK[F] = new MkMonoidK[F] { @@ -60,7 +60,7 @@ private[derived] abstract class MkMonoidKNestedOuter extends MkMonoidKNestedInne } } -private[derived] abstract class MkMonoidKNestedInner extends MkMonoidKGeneric { +abstract private[derived] class MkMonoidKNestedInner extends MkMonoidKGeneric { implicit def mkMonoidKNestedInner[F[_]](implicit F: Split1[F, Applicative, MonoidKOrMk]): MkMonoidK[F] = new MkMonoidK[F] { @@ -69,7 +69,7 @@ private[derived] abstract class MkMonoidKNestedInner extends MkMonoidKGeneric { } } -private[derived] abstract class MkMonoidKGeneric { +abstract private[derived] class MkMonoidKGeneric { protected type MonoidKOrMk[F[_]] = MonoidK[F] OrElse MkMonoidK[F] implicit def mkMonoidKHcons[F[_]](implicit F: IsHCons1[F, MonoidKOrMk, MkMonoidK]): MkMonoidK[F] = @@ -81,7 +81,7 @@ private[derived] abstract class MkMonoidKGeneric { val (fhy, fty) = F.unpack(y) F.pack(F.fh.unify.combineK(fhx, fhy), F.ft.combineK(ftx, fty)) } - } + } implicit def mkMonoidKGeneric[F[_]](implicit F: Generic1[F, MkMonoidK]): MkMonoidK[F] = new MkMonoidK[F] { diff --git a/core/src/main/scala/cats/derived/nonEmptyTraverse.scala b/core/src/main/scala/cats/derived/nonEmptyTraverse.scala index 8d451b51..d48d03a2 100644 --- a/core/src/main/scala/cats/derived/nonEmptyTraverse.scala +++ b/core/src/main/scala/cats/derived/nonEmptyTraverse.scala @@ -46,10 +46,10 @@ object MkNonEmptyTraverse extends MkNonEmptyTraverseDerivation { def apply[F[_]](implicit F: MkNonEmptyTraverse[F]): MkNonEmptyTraverse[F] = F } -private[derived] abstract class MkNonEmptyTraverseDerivation extends MkNonEmptyTraverseBase { +abstract private[derived] class MkNonEmptyTraverseDerivation extends MkNonEmptyTraverseBase { - implicit def mkNonEmptyTraverseNested[F[_]]( - implicit F: Split1[F, NonEmptyTraverseOrMk, NonEmptyTraverseOrMk] + implicit def mkNonEmptyTraverseNested[F[_]](implicit + F: Split1[F, NonEmptyTraverseOrMk, NonEmptyTraverseOrMk] ): MkNonEmptyTraverse[F] = new MkNonEmptyTraverseInstance( MkTraverse.mkTraverseNested(F.asInstanceOf[Split1[F, TraverseOrMk, TraverseOrMk]]), MkReducible.mkReducibleNested(F.asInstanceOf[Split1[F, ReducibleOrMk, ReducibleOrMk]]) @@ -59,10 +59,10 @@ private[derived] abstract class MkNonEmptyTraverseDerivation extends MkNonEmptyT } } -private[derived] abstract class MkNonEmptyTraverseBase extends MkNonEmptyTraverseCons { +abstract private[derived] class MkNonEmptyTraverseBase extends MkNonEmptyTraverseCons { - implicit def mkNonEmptyTraverseHConsBase[F[_]]( - implicit F: IsHCons1[F, NonEmptyTraverseOrMk, MkTraverse] + implicit def mkNonEmptyTraverseHConsBase[F[_]](implicit + F: IsHCons1[F, NonEmptyTraverseOrMk, MkTraverse] ): MkNonEmptyTraverse[F] = new MkNonEmptyTraverseInstance( MkTraverse.mkTraverseHCons(F.asInstanceOf[IsHCons1[F, TraverseOrMk, MkTraverse]]), MkReducible.mkReducibleHConsBase(F.asInstanceOf[IsHCons1[F, ReducibleOrMk, MkFoldable]]) @@ -85,15 +85,15 @@ private[derived] abstract class MkNonEmptyTraverseBase extends MkNonEmptyTravers } } -private[derived] abstract class MkNonEmptyTraverseCons extends MkNonEmptyTraverseGeneric { +abstract private[derived] class MkNonEmptyTraverseCons extends MkNonEmptyTraverseGeneric { - implicit def mkNonEmptyTraverseHCons[F[_]]( - implicit F: IsHCons1[F, TraverseOrMk, MkNonEmptyTraverse] + implicit def mkNonEmptyTraverseHCons[F[_]](implicit + F: IsHCons1[F, TraverseOrMk, MkNonEmptyTraverse] ): MkNonEmptyTraverse[F] = new MkNonEmptyTraverseInstance( MkTraverse.mkTraverseHCons(F.asInstanceOf[IsHCons1[F, TraverseOrMk, MkTraverse]]), MkReducible.mkReducibleHCons(F.asInstanceOf[IsHCons1[F, FoldableOrMk, MkReducible]]) ) { - def safeNonEmptyTraverse[G[_], A, B](fa: F[A])(f: A => Eval[G[B]])(implicit G: Apply[G]) = { + def safeNonEmptyTraverse[G[_], A, B](fa: F[A])(f: A => Eval[G[B]])(implicit G: Apply[G]) = Eval.now(F.unpack(fa)).flatMap { case (fha, fta) => for { gfhb <- MkTraverse.mkSafeTraverse(F.fh)(fha)(f(_).map[G OrPure B](Left.apply)) @@ -103,11 +103,10 @@ private[derived] abstract class MkNonEmptyTraverseCons extends MkNonEmptyTravers case Right(fhb) => G.map(gftb)(ftb => F.pack(fhb -> ftb)) } } - } } - implicit def mkNonEmptyTraverseCCons[F[_]]( - implicit F: IsCCons1[F, NonEmptyTraverseOrMk, MkNonEmptyTraverse] + implicit def mkNonEmptyTraverseCCons[F[_]](implicit + F: IsCCons1[F, NonEmptyTraverseOrMk, MkNonEmptyTraverse] ): MkNonEmptyTraverse[F] = new MkNonEmptyTraverseInstance( MkTraverse.mkTraverseCCons(F.asInstanceOf[IsCCons1[F, TraverseOrMk, MkTraverse]]), MkReducible.mkReducibleCCons(F.asInstanceOf[IsCCons1[F, ReducibleOrMk, MkReducible]]) @@ -120,19 +119,19 @@ private[derived] abstract class MkNonEmptyTraverseCons extends MkNonEmptyTravers } } -private[derived] abstract class MkNonEmptyTraverseGeneric { +abstract private[derived] class MkNonEmptyTraverseGeneric { protected type FoldableOrMk[F[_]] = Foldable[F] OrElse MkFoldable[F] protected type ReducibleOrMk[F[_]] = Reducible[F] OrElse MkReducible[F] protected type TraverseOrMk[F[_]] = Traverse[F] OrElse MkTraverse[F] protected type NonEmptyTraverseOrMk[F[_]] = NonEmptyTraverse[F] OrElse MkNonEmptyTraverse[F] protected type OrPure[F[_], A] = Either[F[A], A] - protected abstract class MkNonEmptyTraverseInstance[F[_]]( - mkTraverse: MkTraverse[F], - mkReducible: MkReducible[F] + abstract protected class MkNonEmptyTraverseInstance[F[_]]( + mkTraverse: MkTraverse[F], + mkReducible: MkReducible[F] ) extends MkNonEmptyTraverse[F] { - def safeTraverse[G[_] : Applicative, A, B](fa: F[A])(f: A => Eval[G[B]]): Eval[G[F[B]]] = + def safeTraverse[G[_]: Applicative, A, B](fa: F[A])(f: A => Eval[G[B]]): Eval[G[F[B]]] = mkTraverse.safeTraverse(fa)(f) def safeReduceLeftTo[A, B](fa: F[A])(f: A => B)(g: (B, A) => Eval[B]): Eval[B] = @@ -149,13 +148,13 @@ private[derived] abstract class MkNonEmptyTraverseGeneric { } protected def mkSafeNonEmptyTraverse[F[_], G[_]: Apply, A, B]( - F: NonEmptyTraverseOrMk[F] + F: NonEmptyTraverseOrMk[F] )(fa: F[A])(f: A => Eval[G[B]]): Eval[G[F[B]]] = F.unify match { case mk: MkNonEmptyTraverse[F] => mk.safeNonEmptyTraverse(fa)(f) case other => Eval.later(other.nonEmptyTraverse(fa)(f(_).value)) } - protected implicit def orPureApplicative[F[_]](implicit F: Apply[F]): Applicative[F OrPure *] = + implicit protected def orPureApplicative[F[_]](implicit F: Apply[F]): Applicative[F OrPure *] = new Applicative[F OrPure *] { def pure[A](x: A) = Right(x) diff --git a/core/src/main/scala/cats/derived/order.scala b/core/src/main/scala/cats/derived/order.scala index c145fcc7..4fea10f4 100644 --- a/core/src/main/scala/cats/derived/order.scala +++ b/core/src/main/scala/cats/derived/order.scala @@ -32,12 +32,13 @@ object MkOrder extends MkOrderDerivation { def apply[A](implicit ev: MkOrder[A]): MkOrder[A] = ev } -private[derived] abstract class MkOrderDerivation { +abstract private[derived] class MkOrderDerivation { implicit val mkOrderHNil: MkOrder[HNil] = instance((_, _) => 0) implicit val mkOrderCNil: MkOrder[CNil] = instance((_, _) => 0) - implicit def mkOrderHCons[H, T <: HList]( - implicit H: Order[H] OrElse MkOrder[H], T: MkOrder[T] + implicit def mkOrderHCons[H, T <: HList](implicit + H: Order[H] OrElse MkOrder[H], + T: MkOrder[T] ): MkOrder[H :: T] = instance { case (hx :: tx, hy :: ty) => val cmpH = H.unify.compare(hx, hy) if (cmpH != 0) cmpH else T.compare(tx, ty) diff --git a/core/src/main/scala/cats/derived/package.scala b/core/src/main/scala/cats/derived/package.scala index 990ade48..aba23202 100644 --- a/core/src/main/scala/cats/derived/package.scala +++ b/core/src/main/scala/cats/derived/package.scala @@ -6,8 +6,7 @@ import cats.derived.util.VersionSpecific.Lazy import cats.kernel.{CommutativeMonoid, CommutativeSemigroup} import shapeless.{Cached, Refute} -/** - * Fully automatically derive the instance, note that this derivation is not cached, so it +/** Fully automatically derive the instance, note that this derivation is not cached, so it * will re-derive every time an instance is needed in the application, which could * significantly impact the compilation time. */ @@ -19,315 +18,364 @@ object auto { } object empty { - implicit def kittensMkEmpty[A]( - implicit refute: Refute[Empty[A]], ev: Lazy[MkEmpty[A]] + implicit def kittensMkEmpty[A](implicit + refute: Refute[Empty[A]], + ev: Lazy[MkEmpty[A]] ): Empty[A] = ev.value } object emptyK { - implicit def kittensMkEmptyK[F[_]]( - implicit refute: Refute[EmptyK[F]], F: Lazy[MkEmptyK[F]] + implicit def kittensMkEmptyK[F[_]](implicit + refute: Refute[EmptyK[F]], + F: Lazy[MkEmptyK[F]] ): EmptyK[F] = F.value } object eq { - implicit def kittensMkEq[A]( - implicit refute: Refute[Eq[A]], ev: Lazy[MkEq[A]] + implicit def kittensMkEq[A](implicit + refute: Refute[Eq[A]], + ev: Lazy[MkEq[A]] ): Eq[A] = ev.value } object partialOrder { - implicit def kittensMkPartialOrder[A]( - implicit refute: Refute[PartialOrder[A]], ev: Lazy[MkPartialOrder[A]] + implicit def kittensMkPartialOrder[A](implicit + refute: Refute[PartialOrder[A]], + ev: Lazy[MkPartialOrder[A]] ): PartialOrder[A] = ev.value } object order { - implicit def kittensMkOrder[A]( - implicit refute: Refute[Order[A]], ev: Lazy[MkOrder[A]] + implicit def kittensMkOrder[A](implicit + refute: Refute[Order[A]], + ev: Lazy[MkOrder[A]] ): Order[A] = ev.value } object hash { - implicit def kittensMkHash[A]( - implicit refute: Refute[Hash[A]], ev: Lazy[MkHash[A]] + implicit def kittensMkHash[A](implicit + refute: Refute[Hash[A]], + ev: Lazy[MkHash[A]] ): Hash[A] = ev.value } object invariant { - implicit def kittensMkInvariant[F[_]]( - implicit refute: Refute[Invariant[F]], F: Lazy[MkInvariant[F]] + implicit def kittensMkInvariant[F[_]](implicit + refute: Refute[Invariant[F]], + F: Lazy[MkInvariant[F]] ): Invariant[F] = F.value } - object contravariant { - implicit def kittensMkContravariant[F[_]]( - implicit refute: Refute[Contravariant[F]], F: Lazy[MkContravariant[F]] + object contravariant { + implicit def kittensMkContravariant[F[_]](implicit + refute: Refute[Contravariant[F]], + F: Lazy[MkContravariant[F]] ): Contravariant[F] = F.value } object functor { - implicit def kittensMkFunctor[F[_]]( - implicit refute: Refute[Functor[F]], F: Lazy[MkFunctor[F]] + implicit def kittensMkFunctor[F[_]](implicit + refute: Refute[Functor[F]], + F: Lazy[MkFunctor[F]] ): Functor[F] = F.value } object apply { - implicit def kittensMkApply[F[_]]( - implicit refute: Refute[Apply[F]], F: Lazy[MkApply[F]] + implicit def kittensMkApply[F[_]](implicit + refute: Refute[Apply[F]], + F: Lazy[MkApply[F]] ): Apply[F] = F.value } object applicative { - implicit def kittensMkApplicative[F[_]]( - implicit refute: Refute[Applicative[F]], F: Lazy[MkApplicative[F]] + implicit def kittensMkApplicative[F[_]](implicit + refute: Refute[Applicative[F]], + F: Lazy[MkApplicative[F]] ): Applicative[F] = F.value } object show { - implicit def kittensMkShow[A]( - implicit refute: Refute[Show[A]], ev: Lazy[MkShow[A]] + implicit def kittensMkShow[A](implicit + refute: Refute[Show[A]], + ev: Lazy[MkShow[A]] ): Show[A] = ev.value } object showPretty { - implicit def kittensMkShowPretty[A]( - implicit refute: Refute[Show[A]], ev: Lazy[MkShowPretty[A]] + implicit def kittensMkShowPretty[A](implicit + refute: Refute[Show[A]], + ev: Lazy[MkShowPretty[A]] ): ShowPretty[A] = ev.value } object semigroup { - implicit def kittensMkSemigroup[A]( - implicit refute: Refute[Semigroup[A]], ev: Lazy[MkSemigroup[A]] + implicit def kittensMkSemigroup[A](implicit + refute: Refute[Semigroup[A]], + ev: Lazy[MkSemigroup[A]] ): Semigroup[A] = ev.value } object commutativeSemigroup { - implicit def kittensMkCommutativeSemigroup[A]( - implicit refute: Refute[CommutativeSemigroup[A]], ev: Lazy[MkCommutativeSemigroup[A]] + implicit def kittensMkCommutativeSemigroup[A](implicit + refute: Refute[CommutativeSemigroup[A]], + ev: Lazy[MkCommutativeSemigroup[A]] ): CommutativeSemigroup[A] = ev.value } object monoid { - implicit def kittensMkMonoid[A]( - implicit refute: Refute[Monoid[A]], ev: Lazy[MkMonoid[A]] + implicit def kittensMkMonoid[A](implicit + refute: Refute[Monoid[A]], + ev: Lazy[MkMonoid[A]] ): Monoid[A] = ev.value } object commutativeMonoid { - implicit def kittensMkCommutativeMonoid[A]( - implicit refute: Refute[CommutativeMonoid[A]], ev: Lazy[MkCommutativeMonoid[A]] + implicit def kittensMkCommutativeMonoid[A](implicit + refute: Refute[CommutativeMonoid[A]], + ev: Lazy[MkCommutativeMonoid[A]] ): CommutativeMonoid[A] = ev.value } object semigroupK { - implicit def kittensMkSemigroupK[F[_]]( - implicit refute: Refute[SemigroupK[F]], F: Lazy[MkSemigroupK[F]] + implicit def kittensMkSemigroupK[F[_]](implicit + refute: Refute[SemigroupK[F]], + F: Lazy[MkSemigroupK[F]] ): SemigroupK[F] = F.value } object monoidK { - implicit def kittensMkMonoidK[F[_]]( - implicit refute: Refute[MonoidK[F]], F: Lazy[MkMonoidK[F]] + implicit def kittensMkMonoidK[F[_]](implicit + refute: Refute[MonoidK[F]], + F: Lazy[MkMonoidK[F]] ): MonoidK[F] = F.value } object foldable { - implicit def kittensMkFoldable[F[_]]( - implicit refute: Refute[Foldable[F]], F: Lazy[MkFoldable[F]] + implicit def kittensMkFoldable[F[_]](implicit + refute: Refute[Foldable[F]], + F: Lazy[MkFoldable[F]] ): Foldable[F] = F.value } object reducible { - implicit def kittensMkReducible[F[_]]( - implicit refute: Refute[Reducible[F]], F: Lazy[MkReducible[F]] + implicit def kittensMkReducible[F[_]](implicit + refute: Refute[Reducible[F]], + F: Lazy[MkReducible[F]] ): Reducible[F] = F.value } object traverse { - implicit def kittensMkTraverse[F[_]]( - implicit refute: Refute[Traverse[F]], F: Lazy[MkTraverse[F]] + implicit def kittensMkTraverse[F[_]](implicit + refute: Refute[Traverse[F]], + F: Lazy[MkTraverse[F]] ): Traverse[F] = F.value } object nonEmptyTraverse { - implicit def kittensMkNonEmptyTraverse[F[_]]( - implicit refute: Refute[NonEmptyTraverse[F]], F: Lazy[MkNonEmptyTraverse[F]] + implicit def kittensMkNonEmptyTraverse[F[_]](implicit + refute: Refute[NonEmptyTraverse[F]], + F: Lazy[MkNonEmptyTraverse[F]] ): NonEmptyTraverse[F] = F.value } object pure { - implicit def kittensMkPure[F[_]]( - implicit refute: Refute[Pure[F]], F: Lazy[MkPure[F]] + implicit def kittensMkPure[F[_]](implicit + refute: Refute[Pure[F]], + F: Lazy[MkPure[F]] ): Pure[F] = F.value } object consK { - implicit def kittensMkConsK[F[_]]( - implicit refute: Refute[ConsK[F]], F: Lazy[MkConsK[F, F]] + implicit def kittensMkConsK[F[_]](implicit + refute: Refute[ConsK[F]], + F: Lazy[MkConsK[F, F]] ): ConsK[F] = MkConsK.consK(F.value) } } -/** - * cached cache the derived instance but this cache are global, so be cautious only use it +/** cached cache the derived instance but this cache are global, so be cautious only use it * when there is only one instance globally in your application. */ object cached { object empty { - implicit def kittensMkEmpty[A]( - implicit refute: Refute[Empty[A]], cached: Cached[MkEmpty[A]] + implicit def kittensMkEmpty[A](implicit + refute: Refute[Empty[A]], + cached: Cached[MkEmpty[A]] ): Empty[A] = cached.value } object emptyK { - implicit def kittensMkEmptyK[F[_]]( - implicit refute: Refute[EmptyK[F]], cached: Cached[MkEmptyK[F]] + implicit def kittensMkEmptyK[F[_]](implicit + refute: Refute[EmptyK[F]], + cached: Cached[MkEmptyK[F]] ): EmptyK[F] = cached.value } object pure { - implicit def kittensMkPure[F[_]]( - implicit refute: Refute[Pure[F]], cached: Cached[MkPure[F]] + implicit def kittensMkPure[F[_]](implicit + refute: Refute[Pure[F]], + cached: Cached[MkPure[F]] ): Pure[F] = cached.value } object eq { - implicit def kittensMkEq[A]( - implicit refute: Refute[Eq[A]], cached: Cached[MkEq[A]] + implicit def kittensMkEq[A](implicit + refute: Refute[Eq[A]], + cached: Cached[MkEq[A]] ): Eq[A] = cached.value } object partialOrder { - implicit def kittensMkPartialOrder[A]( - implicit refute: Refute[PartialOrder[A]], cached: Cached[MkPartialOrder[A]] + implicit def kittensMkPartialOrder[A](implicit + refute: Refute[PartialOrder[A]], + cached: Cached[MkPartialOrder[A]] ): PartialOrder[A] = cached.value } object order { - implicit def kittensMkOrder[A]( - implicit refute: Refute[Order[A]], cached: Cached[MkOrder[A]] + implicit def kittensMkOrder[A](implicit + refute: Refute[Order[A]], + cached: Cached[MkOrder[A]] ): Order[A] = cached.value } object hash { - implicit def kittensMkHash[A]( - implicit refute: Refute[Hash[A]], cached: Cached[MkHash[A]] + implicit def kittensMkHash[A](implicit + refute: Refute[Hash[A]], + cached: Cached[MkHash[A]] ): Hash[A] = cached.value } object contravariant { - implicit def kittensMkContravariant[F[_]]( - implicit refute: Refute[Contravariant[F]], cached: Cached[MkContravariant[F]] + implicit def kittensMkContravariant[F[_]](implicit + refute: Refute[Contravariant[F]], + cached: Cached[MkContravariant[F]] ): Contravariant[F] = cached.value } - + object functor { - implicit def kittensMkFunctor[F[_]]( - implicit refute: Refute[Functor[F]], cached: Cached[MkFunctor[F]] + implicit def kittensMkFunctor[F[_]](implicit + refute: Refute[Functor[F]], + cached: Cached[MkFunctor[F]] ): Functor[F] = cached.value } object apply { - implicit def kittensMkApply[F[_]]( - implicit refute: Refute[Apply[F]], cached: Cached[MkApply[F]] + implicit def kittensMkApply[F[_]](implicit + refute: Refute[Apply[F]], + cached: Cached[MkApply[F]] ): Apply[F] = cached.value } object applicative { - implicit def kittensMkApplicative[F[_]]( - implicit refute: Refute[Applicative[F]], cached: Cached[MkApplicative[F]] + implicit def kittensMkApplicative[F[_]](implicit + refute: Refute[Applicative[F]], + cached: Cached[MkApplicative[F]] ): Applicative[F] = cached.value } object foldable { - implicit def kittensMkFoldable[F[_]]( - implicit refute: Refute[Foldable[F]], cached: Cached[MkFoldable[F]] + implicit def kittensMkFoldable[F[_]](implicit + refute: Refute[Foldable[F]], + cached: Cached[MkFoldable[F]] ): Foldable[F] = cached.value } object reducible { - implicit def kittensMkReducible[F[_]]( - implicit refute: Refute[Reducible[F]], cached: Cached[MkReducible[F]] + implicit def kittensMkReducible[F[_]](implicit + refute: Refute[Reducible[F]], + cached: Cached[MkReducible[F]] ): Reducible[F] = cached.value } object invariant { - implicit def kittensMkInvariant[F[_]]( - implicit refute: Refute[Invariant[F]], cached: Cached[MkInvariant[F]] + implicit def kittensMkInvariant[F[_]](implicit + refute: Refute[Invariant[F]], + cached: Cached[MkInvariant[F]] ): Invariant[F] = cached.value } object traverse { - implicit def kittensMkTraverse[F[_]]( - implicit refute: Refute[Traverse[F]], cached: Cached[MkTraverse[F]] + implicit def kittensMkTraverse[F[_]](implicit + refute: Refute[Traverse[F]], + cached: Cached[MkTraverse[F]] ): Traverse[F] = cached.value } object nonEmptyTraverse { - implicit def kittensMkNonEmptyTraverse[F[_]]( - implicit refute: Refute[NonEmptyTraverse[F]], cached: Cached[MkNonEmptyTraverse[F]] + implicit def kittensMkNonEmptyTraverse[F[_]](implicit + refute: Refute[NonEmptyTraverse[F]], + cached: Cached[MkNonEmptyTraverse[F]] ): NonEmptyTraverse[F] = cached.value } object show { - implicit def kittensMkshow[A]( - implicit refute: Refute[Show[A]], cached: Cached[MkShow[A]] + implicit def kittensMkshow[A](implicit + refute: Refute[Show[A]], + cached: Cached[MkShow[A]] ): Show[A] = cached.value } object showPretty { - implicit def kittensMkShowPretty[A]( - implicit refute: Refute[Show[A]], cached: Cached[MkShowPretty[A]] + implicit def kittensMkShowPretty[A](implicit + refute: Refute[Show[A]], + cached: Cached[MkShowPretty[A]] ): ShowPretty[A] = cached.value } object monoidK { - implicit def kittensMkMonoidK[F[_]]( - implicit refute: Refute[MonoidK[F]], cached: Cached[MkMonoidK[F]] + implicit def kittensMkMonoidK[F[_]](implicit + refute: Refute[MonoidK[F]], + cached: Cached[MkMonoidK[F]] ): MonoidK[F] = cached.value } object semigroup { - implicit def kittensMkSemigroup[A]( - implicit refute: Refute[Semigroup[A]], cached: Cached[MkSemigroup[A]] + implicit def kittensMkSemigroup[A](implicit + refute: Refute[Semigroup[A]], + cached: Cached[MkSemigroup[A]] ): Semigroup[A] = cached.value } object commutativeSemigroup { - implicit def kittensMkCommutativeSemigroup[A]( - implicit refute: Refute[CommutativeSemigroup[A]], cached: Cached[MkCommutativeSemigroup[A]] + implicit def kittensMkCommutativeSemigroup[A](implicit + refute: Refute[CommutativeSemigroup[A]], + cached: Cached[MkCommutativeSemigroup[A]] ): CommutativeSemigroup[A] = cached.value } object monoid { - implicit def kittensMkMonoid[A]( - implicit refute: Refute[Monoid[A]], cached: Cached[MkMonoid[A]] + implicit def kittensMkMonoid[A](implicit + refute: Refute[Monoid[A]], + cached: Cached[MkMonoid[A]] ): Monoid[A] = cached.value } object commutativeMonoid { - implicit def kittensMkCommutativeMonoid[A]( - implicit refute: Refute[CommutativeMonoid[A]], cached: Cached[MkCommutativeMonoid[A]] + implicit def kittensMkCommutativeMonoid[A](implicit + refute: Refute[CommutativeMonoid[A]], + cached: Cached[MkCommutativeMonoid[A]] ): CommutativeMonoid[A] = cached.value } object semigroupK { - implicit def kittensMkSemigroupK[F[_]]( - implicit refute: Refute[SemigroupK[F]], cached: Cached[MkSemigroupK[F]] + implicit def kittensMkSemigroupK[F[_]](implicit + refute: Refute[SemigroupK[F]], + cached: Cached[MkSemigroupK[F]] ): SemigroupK[F] = cached.value } object consK { - implicit def kittensMkConsK[F[_]]( - implicit refute: Refute[ConsK[F]], cached: Cached[MkConsK[F, F]] + implicit def kittensMkConsK[F[_]](implicit + refute: Refute[ConsK[F]], + cached: Cached[MkConsK[F, F]] ): ConsK[F] = MkConsK.consK(cached.value) } } -private[derived] abstract class SemiAutoInstances { +abstract private[derived] class SemiAutoInstances { def eq[A](implicit ev: Lazy[MkEq[A]]): Eq[A] = ev.value def partialOrder[A](implicit ev: Lazy[MkPartialOrder[A]]): PartialOrder[A] = ev.value @@ -364,8 +412,7 @@ private[derived] abstract class SemiAutoInstances { def iterable[F[_], A](fa: F[A])(implicit F: MkIterable[F]): Iterable[A] = F.iterable(fa) } -/** - * allows semi automatically derive each instance. The derivation might need help when +/** allows semi automatically derive each instance. The derivation might need help when * there are fields with a type constructor that comes with instances, e.g. * {{{ * scala> case class Bar(a: String) diff --git a/core/src/main/scala/cats/derived/partialOrder.scala b/core/src/main/scala/cats/derived/partialOrder.scala index 5a0e9631..370dbe65 100644 --- a/core/src/main/scala/cats/derived/partialOrder.scala +++ b/core/src/main/scala/cats/derived/partialOrder.scala @@ -32,27 +32,30 @@ object MkPartialOrder extends MkPartialOrderDerivation { def apply[A](implicit ev: MkPartialOrder[A]): MkPartialOrder[A] = ev } -private[derived] abstract class MkPartialOrderDerivation { +abstract private[derived] class MkPartialOrderDerivation { implicit val mkPartialOrderHNil: MkPartialOrder[HNil] = instance((_, _) => 0) implicit val mkPartialOrderCNil: MkPartialOrder[CNil] = instance((_, _) => 0) - implicit def mkPartialOrderHcons[H, T <: HList]( - implicit H: PartialOrder[H] OrElse MkPartialOrder[H], T: MkPartialOrder[T] + implicit def mkPartialOrderHcons[H, T <: HList](implicit + H: PartialOrder[H] OrElse MkPartialOrder[H], + T: MkPartialOrder[T] ): MkPartialOrder[H :: T] = instance { case (hx :: tx, hy :: ty) => val cmpH = H.unify.partialCompare(hx, hy) if (cmpH != 0) cmpH else T.partialCompare(tx, ty) } - implicit def mkPartialOrderCCons[L, R <: Coproduct]( - implicit L: PartialOrder[L] OrElse MkPartialOrder[L], R: MkPartialOrder[R] + implicit def mkPartialOrderCCons[L, R <: Coproduct](implicit + L: PartialOrder[L] OrElse MkPartialOrder[L], + R: MkPartialOrder[R] ): MkPartialOrder[L :+: R] = instance { case (Inl(lx), Inl(ly)) => L.unify.partialCompare(lx, ly) case (Inr(rx), Inr(ry)) => R.partialCompare(rx, ry) case _ => Double.NaN } - implicit def mkPartialOrderGeneric[A, R]( - implicit A: Generic.Aux[A, R], R: Lazy[MkPartialOrder[R]] + implicit def mkPartialOrderGeneric[A, R](implicit + A: Generic.Aux[A, R], + R: Lazy[MkPartialOrder[R]] ): MkPartialOrder[A] = instance((x, y) => R.value.partialCompare(A.to(x), A.to(y))) private def instance[A](f: (A, A) => Double): MkPartialOrder[A] = diff --git a/core/src/main/scala/cats/derived/pure.scala b/core/src/main/scala/cats/derived/pure.scala index 68bb5e6a..f633d359 100644 --- a/core/src/main/scala/cats/derived/pure.scala +++ b/core/src/main/scala/cats/derived/pure.scala @@ -35,7 +35,7 @@ object MkPure extends MkPureDerivation { def apply[F[_]](implicit F: MkPure[F]): MkPure[F] = F } -private[derived] abstract class MkPureDerivation extends MkPureNested { +abstract private[derived] class MkPureDerivation extends MkPureNested { implicit val mkPureHNil: MkPure[Const[HNil]#λ] = new MkPure[Const[HNil]#λ] { @@ -48,7 +48,7 @@ private[derived] abstract class MkPureDerivation extends MkPureNested { } } -private[derived] abstract class MkPureNested extends MkPureCons { +abstract private[derived] class MkPureNested extends MkPureCons { implicit def mkPureNested[F[_]](implicit F: Split1[F, PureOrMk, PureOrMk]): MkPure[F] = new MkPure[F] { @@ -56,7 +56,7 @@ private[derived] abstract class MkPureNested extends MkPureCons { } } -private[derived] abstract class MkPureCons extends MkPureGeneric { +abstract private[derived] class MkPureCons extends MkPureGeneric { implicit def mkPureHCons[F[_]](implicit F: IsHCons1[F, PureOrMk, MkPure]): MkPure[F] = new MkPure[F] { @@ -64,7 +64,7 @@ private[derived] abstract class MkPureCons extends MkPureGeneric { } } -private[derived] abstract class MkPureGeneric { +abstract private[derived] class MkPureGeneric { protected type PureOrMk[F[_]] = Pure[F] OrElse MkPure[F] implicit def mkPureGeneric[F[_]](implicit F: Generic1[F, MkPure]): MkPure[F] = diff --git a/core/src/main/scala/cats/derived/reducible.scala b/core/src/main/scala/cats/derived/reducible.scala index 5e1b5987..07a29aa6 100644 --- a/core/src/main/scala/cats/derived/reducible.scala +++ b/core/src/main/scala/cats/derived/reducible.scala @@ -40,27 +40,27 @@ object MkReducible extends MkReducibleDerivation { def apply[F[_]](implicit F: MkReducible[F]): MkReducible[F] = F } -private[derived] abstract class MkReducibleDerivation extends MkReducibleBase { +abstract private[derived] class MkReducibleDerivation extends MkReducibleBase { implicit def mkReducibleNested[F[_]](implicit F: Split1[F, ReducibleOrMk, ReducibleOrMk]): MkReducible[F] = new MkReducibleInstance(MkFoldable.mkFoldableNested(F.asInstanceOf[Split1[F, FoldableOrMk, FoldableOrMk]])) { def safeReduceLeftTo[A, B](fa: F[A])(f: A => B)(g: (B, A) => Eval[B]) = - mkSafeReduceLeftTo(F.fo)(F.unpack(fa))(mkSafeReduceLeftTo(F.fi)(_)(f)(g)) { - (lb, fia) => lb.map(MkFoldable.mkSafeFoldLeft(F.fi)(fia, _)(g)) + mkSafeReduceLeftTo(F.fo)(F.unpack(fa))(mkSafeReduceLeftTo(F.fi)(_)(f)(g)) { (lb, fia) => + lb.map(MkFoldable.mkSafeFoldLeft(F.fi)(fia, _)(g)) }.flatMap(identity) def reduceRightTo[A, B](fa: F[A])(f: A => B)(g: (A, Eval[B]) => Eval[B]) = { val fo = F.fo.unify val fi = F.fi.unify - fo.reduceRightTo(F.unpack(fa))(fi.reduceRightTo(_)(f)(g)) { - (fia, llb) => Eval.later(fi.foldRight(fia, llb.value)(g)) + fo.reduceRightTo(F.unpack(fa))(fi.reduceRightTo(_)(f)(g)) { (fia, llb) => + Eval.later(fi.foldRight(fia, llb.value)(g)) }.flatMap(identity) } } } -private[derived] abstract class MkReducibleBase extends MkReducibleCons { +abstract private[derived] class MkReducibleBase extends MkReducibleCons { implicit def mkReducibleHConsBase[F[_]](implicit F: IsHCons1[F, ReducibleOrMk, MkFoldable]): MkReducible[F] = new MkReducibleInstance(MkFoldable.mkFoldableHCons(F.asInstanceOf[IsHCons1[F, FoldableOrMk, MkFoldable]])) { @@ -86,20 +86,22 @@ private[derived] abstract class MkReducibleBase extends MkReducibleCons { } } -private[derived] abstract class MkReducibleCons extends MkReducibleGeneric { +abstract private[derived] class MkReducibleCons extends MkReducibleGeneric { implicit def mkReducibleHCons[F[_]](implicit F: IsHCons1[F, FoldableOrMk, MkReducible]): MkReducible[F] = new MkReducibleInstance(MkFoldable.mkFoldableHCons(F.asInstanceOf[IsHCons1[F, FoldableOrMk, MkFoldable]])) { def safeReduceLeftTo[A, B](fa: F[A])(f: A => B)(g: (B, A) => Eval[B]) = Eval.now(F.unpack(fa)).flatMap { case (fha, fta) => - MkFoldable.mkSafeFoldLeft(F.fh)(fha, Option.empty[B]) { - case (Some(b), a) => g(b, a).map(Some.apply) - case (None, a) => Eval.now(Some(f(a))) - }.flatMap { - case Some(b) => F.ft.safeFoldLeft(fta, b)(g) - case None => F.ft.safeReduceLeftTo(fta)(f)(g) - } + MkFoldable + .mkSafeFoldLeft(F.fh)(fha, Option.empty[B]) { + case (Some(b), a) => g(b, a).map(Some.apply) + case (None, a) => Eval.now(Some(f(a))) + } + .flatMap { + case Some(b) => F.ft.safeFoldLeft(fta, b)(g) + case None => F.ft.safeReduceLeftTo(fta)(f)(g) + } } def reduceRightTo[A, B](fa: F[A])(f: A => B)(g: (A, Eval[B]) => Eval[B]) = @@ -125,11 +127,11 @@ private[derived] abstract class MkReducibleCons extends MkReducibleGeneric { } } -private[derived] abstract class MkReducibleGeneric { +abstract private[derived] class MkReducibleGeneric { protected type FoldableOrMk[F[_]] = Foldable[F] OrElse MkFoldable[F] protected type ReducibleOrMk[F[_]] = Reducible[F] OrElse MkReducible[F] - protected abstract class MkReducibleInstance[F[_]](foldable: MkFoldable[F]) extends MkReducible[F] { + abstract protected class MkReducibleInstance[F[_]](foldable: MkFoldable[F]) extends MkReducible[F] { def safeFoldLeft[A, B](fa: F[A], b: B)(f: (B, A) => Eval[B]) = foldable.safeFoldLeft(fa, b)(f) @@ -139,7 +141,7 @@ private[derived] abstract class MkReducibleGeneric { } protected def mkSafeReduceLeftTo[F[_], A, B]( - F: ReducibleOrMk[F] + F: ReducibleOrMk[F] )(fa: F[A])(f: A => B)(g: (B, A) => Eval[B]): Eval[B] = F.unify match { case mk: MkReducible[F] => mk.safeReduceLeftTo(fa)(f)(g) case other => Eval.later(other.reduceLeftTo(fa)(f)(g(_, _).value)) diff --git a/core/src/main/scala/cats/derived/semigroup.scala b/core/src/main/scala/cats/derived/semigroup.scala index 7e319793..40dd19ad 100644 --- a/core/src/main/scala/cats/derived/semigroup.scala +++ b/core/src/main/scala/cats/derived/semigroup.scala @@ -30,13 +30,14 @@ object MkSemigroup extends MkSemigroupDerivation { def apply[A](implicit ev: MkSemigroup[A]): MkSemigroup[A] = ev } -private[derived] abstract class MkSemigroupDerivation { +abstract private[derived] class MkSemigroupDerivation { implicit val mkSemigroupHNil: MkSemigroup[HNil] = instance((_, _) => HNil) - implicit def mkSemigroupHCons[H, T <: HList]( - implicit H: Semigroup[H] OrElse MkSemigroup[H], T: MkSemigroup[T] + implicit def mkSemigroupHCons[H, T <: HList](implicit + H: Semigroup[H] OrElse MkSemigroup[H], + T: MkSemigroup[T] ): MkSemigroup[H :: T] = instance { case (hx :: tx, hy :: ty) => H.unify.combine(hx, hy) :: T.combine(tx, ty) } @@ -49,4 +50,3 @@ private[derived] abstract class MkSemigroupDerivation { def combine(x: A, y: A) = f(x, y) } } - diff --git a/core/src/main/scala/cats/derived/semigroupk.scala b/core/src/main/scala/cats/derived/semigroupk.scala index 8ecfc478..be531fd8 100644 --- a/core/src/main/scala/cats/derived/semigroupk.scala +++ b/core/src/main/scala/cats/derived/semigroupk.scala @@ -36,7 +36,7 @@ object MkSemigroupK extends MkSemigroupKDerivation { def apply[F[_]](implicit F: MkSemigroupK[F]): MkSemigroupK[F] = F } -private[derived] abstract class MkSemigroupKDerivation extends MkSemigroupKNestedOuter { +abstract private[derived] class MkSemigroupKDerivation extends MkSemigroupKNestedOuter { implicit val mkSemigroupKHNil: MkSemigroupK[Const[HNil]#λ] = new MkSemigroupK[Const[HNil]#λ] { @@ -49,7 +49,7 @@ private[derived] abstract class MkSemigroupKDerivation extends MkSemigroupKNeste } } -private[derived] abstract class MkSemigroupKNestedOuter extends MkSemigroupKNestedInner { +abstract private[derived] class MkSemigroupKNestedOuter extends MkSemigroupKNestedInner { implicit def mkSemigroupKNestedOuter[F[_]](implicit F: Split1[F, SemigroupKOrMk, Trivial1]): MkSemigroupK[F] = new MkSemigroupK[F] { @@ -59,7 +59,7 @@ private[derived] abstract class MkSemigroupKNestedOuter extends MkSemigroupKNest } } -private[derived] abstract class MkSemigroupKNestedInner extends MkSemigroupKGeneric { +abstract private[derived] class MkSemigroupKNestedInner extends MkSemigroupKGeneric { implicit def mkSemigroupKNestedInner[F[_]](implicit F: Split1[F, Apply, SemigroupKOrMk]): MkSemigroupK[F] = new MkSemigroupK[F] { @@ -69,7 +69,7 @@ private[derived] abstract class MkSemigroupKNestedInner extends MkSemigroupKGen } } -private[derived] abstract class MkSemigroupKGeneric { +abstract private[derived] class MkSemigroupKGeneric { protected type SemigroupKOrMk[F[_]] = SemigroupK[F] OrElse MkSemigroupK[F] implicit def mkSemigroupKHCons[F[_]](implicit F: IsHCons1[F, SemigroupKOrMk, MkSemigroupK]): MkSemigroupK[F] = diff --git a/core/src/main/scala/cats/derived/show.scala b/core/src/main/scala/cats/derived/show.scala index 56304c22..864bf2d1 100644 --- a/core/src/main/scala/cats/derived/show.scala +++ b/core/src/main/scala/cats/derived/show.scala @@ -7,18 +7,17 @@ import util.VersionSpecific.{OrElse, Lazy} import scala.annotation.implicitNotFound -/** - * Due to a limitation in the way Shapeless' `describe` is currently - * implemented, `Show` can't be derived for ADTs which are _both_ - * recursive _and_ generic in one or more type parameters. - * - * See: - * https://github.com/typelevel/kittens/pull/48#issue-249836267 - * https://github.com/milessabin/shapeless/issues/750 - * - * See the test suite for more precise examples of what can and cannot - * be derived. - */ +/** Due to a limitation in the way Shapeless' `describe` is currently + * implemented, `Show` can't be derived for ADTs which are _both_ + * recursive _and_ generic in one or more type parameters. + * + * See: + * https://github.com/typelevel/kittens/pull/48#issue-249836267 + * https://github.com/milessabin/shapeless/issues/750 + * + * See the test suite for more precise examples of what can and cannot + * be derived. + */ @implicitNotFound("""Could not derive an instance of Show[A] where A = ${A}. Make sure that A has a Typeable instance and satisfies one of the following conditions: * it is a case class where all fields have a Show instance @@ -29,12 +28,14 @@ object MkShow extends MkShowDerivation { def apply[A](implicit ev: MkShow[A]): MkShow[A] = ev } -private[derived] abstract class MkShowDerivation extends MkShowGenericCoproduct { +abstract private[derived] class MkShowDerivation extends MkShowGenericCoproduct { implicit val mkShowHNil: MkShow[HNil] = instance(_ => "") implicit val mkShowCNil: MkShow[CNil] = instance(_ => "") - implicit def mkShowLabelledHCons[K <: Symbol, V, T <: HList]( - implicit K: Witness.Aux[K], V: Show[V] OrElse MkShow[V], T: MkShow[T] + implicit def mkShowLabelledHCons[K <: Symbol, V, T <: HList](implicit + K: Witness.Aux[K], + V: Show[V] OrElse MkShow[V], + T: MkShow[T] ): MkShow[FieldType[K, V] :: T] = instance { case v :: t => val name = K.value.name val value = V.unify.show(v) @@ -43,15 +44,18 @@ private[derived] abstract class MkShowDerivation extends MkShowGenericCoproduct else s"$name = $value, $tail" } - implicit def mkShowCCons[L, R <: Coproduct]( - implicit L: Show[L] OrElse MkShow[L], R: MkShow[R] + implicit def mkShowCCons[L, R <: Coproduct](implicit + L: Show[L] OrElse MkShow[L], + R: MkShow[R] ): MkShow[L :+: R] = instance { case Inl(l) => L.unify.show(l) case Inr(r) => R.show(r) } - implicit def mkShowGenericProduct[A, R <: HList]( - implicit A: LabelledGeneric.Aux[A, R], T: Typeable[A], R: Lazy[MkShow[R]] + implicit def mkShowGenericProduct[A, R <: HList](implicit + A: LabelledGeneric.Aux[A, R], + T: Typeable[A], + R: Lazy[MkShow[R]] ): MkShow[A] = instance { a => val name = T.describe.takeWhile(_ != '[') val fields = R.value.show(A.to(a)) @@ -59,10 +63,11 @@ private[derived] abstract class MkShowDerivation extends MkShowGenericCoproduct } } -private[derived] abstract class MkShowGenericCoproduct { +abstract private[derived] class MkShowGenericCoproduct { - implicit def mkShowGenericCoproduct[A, R <: Coproduct]( - implicit A: Generic.Aux[A, R], R: Lazy[MkShow[R]] + implicit def mkShowGenericCoproduct[A, R <: Coproduct](implicit + A: Generic.Aux[A, R], + R: Lazy[MkShow[R]] ): MkShow[A] = instance(a => R.value.show(A.to(a))) protected def instance[A](f: A => String): MkShow[A] = diff --git a/core/src/main/scala/cats/derived/showPretty.scala b/core/src/main/scala/cats/derived/showPretty.scala index 74ed50c6..f5311425 100644 --- a/core/src/main/scala/cats/derived/showPretty.scala +++ b/core/src/main/scala/cats/derived/showPretty.scala @@ -26,12 +26,14 @@ object MkShowPretty extends MkShowPrettyDerivation { def apply[A](implicit ev: MkShowPretty[A]): MkShowPretty[A] = ev } -private[derived] abstract class MkShowPrettyDerivation extends MkShowPrettyGenericCoproduct { +abstract private[derived] class MkShowPrettyDerivation extends MkShowPrettyGenericCoproduct { implicit val mkShowPrettyHNil: MkShowPretty[HNil] = instance(_ => Nil) implicit val mkShowPrettyCNil: MkShowPretty[CNil] = instance(_ => Nil) - implicit def mkShowPrettyLabelledHCons[K <: Symbol, V, T <: HList]( - implicit K: Witness.Aux[K], V: Show[V] OrElse MkShowPretty[V], T: MkShowPretty[T] + implicit def mkShowPrettyLabelledHCons[K <: Symbol, V, T <: HList](implicit + K: Witness.Aux[K], + V: Show[V] OrElse MkShowPretty[V], + T: MkShowPretty[T] ): MkShowPretty[FieldType[K, V] :: T] = instance { case v :: t => val name = K.value.name val valueLines = mkShowLines(V)(v) @@ -47,15 +49,18 @@ private[derived] abstract class MkShowPrettyDerivation extends MkShowPrettyGener else headLine :: middleLines.init ::: s"${middleLines.last}," :: tailLines } - implicit def mkShowPrettyCCons[L, R <: Coproduct]( - implicit L: Show[L] OrElse MkShowPretty[L], R: MkShowPretty[R] + implicit def mkShowPrettyCCons[L, R <: Coproduct](implicit + L: Show[L] OrElse MkShowPretty[L], + R: MkShowPretty[R] ): MkShowPretty[L :+: R] = instance { case Inl(l) => mkShowLines(L)(l) case Inr(r) => R.showLines(r) } - implicit def mkShowPrettyGenericProduct[A, R <: HList]( - implicit A: LabelledGeneric.Aux[A, R], T: Typeable[A], R: Lazy[MkShowPretty[R]] + implicit def mkShowPrettyGenericProduct[A, R <: HList](implicit + A: LabelledGeneric.Aux[A, R], + T: Typeable[A], + R: Lazy[MkShowPretty[R]] ): MkShowPretty[A] = instance { a => val name = T.describe.takeWhile(_ != '[') val lines = R.value.showLines(A.to(a)).map(" " + _) @@ -63,7 +68,7 @@ private[derived] abstract class MkShowPrettyDerivation extends MkShowPrettyGener } } -private[derived] abstract class MkShowPrettyGenericCoproduct { +abstract private[derived] class MkShowPrettyGenericCoproduct { protected def instance[A](f: A => List[String]): MkShowPretty[A] = new MkShowPretty[A] { @@ -71,12 +76,16 @@ private[derived] abstract class MkShowPrettyGenericCoproduct { } protected def mkShowLines[A](show: Show[A] OrElse MkShowPretty[A])(a: A): List[String] = - show.fold({ - case pretty: ShowPretty[A] => pretty.showLines(a) - case other => other.show(a).split(System.lineSeparator).toList - }, _.showLines(a)) + show.fold( + { + case pretty: ShowPretty[A] => pretty.showLines(a) + case other => other.show(a).split(System.lineSeparator).toList + }, + _.showLines(a) + ) - implicit def mkShowPrettyGenericCoproduct[A, R <: Coproduct]( - implicit A: Generic.Aux[A, R], R: Lazy[MkShowPretty[R]] + implicit def mkShowPrettyGenericCoproduct[A, R <: Coproduct](implicit + A: Generic.Aux[A, R], + R: Lazy[MkShowPretty[R]] ): MkShowPretty[A] = instance(a => R.value.showLines(A.to(a))) } diff --git a/core/src/main/scala/cats/derived/traverse.scala b/core/src/main/scala/cats/derived/traverse.scala index 1d3aaefc..5abc8cea 100644 --- a/core/src/main/scala/cats/derived/traverse.scala +++ b/core/src/main/scala/cats/derived/traverse.scala @@ -29,7 +29,7 @@ object MkTraverse extends MkTraverseDerivation { def apply[F[_]](implicit F: MkTraverse[F]): MkTraverse[F] = F } -private[derived] abstract class MkTraverseDerivation extends MkTraverseNested { +abstract private[derived] class MkTraverseDerivation extends MkTraverseNested { implicit val mkTraverseHNil: MkTraverse[Const[HNil]#λ] = mkTraverseConst implicit val mkTraverseCNil: MkTraverse[Const[CNil]#λ] = mkTraverseConst @@ -40,7 +40,7 @@ private[derived] abstract class MkTraverseDerivation extends MkTraverseNested { } } -private[derived] abstract class MkTraverseNested extends MkTraverseCons { +abstract private[derived] class MkTraverseNested extends MkTraverseCons { implicit def mkTraverseNested[F[_]](implicit F: Split1[F, TraverseOrMk, TraverseOrMk]): MkTraverse[F] = new MkTraverse[F] { @@ -56,7 +56,7 @@ private[derived] abstract class MkTraverseNested extends MkTraverseCons { } } -private[derived] abstract class MkTraverseCons extends MkTraverseGeneric { +abstract private[derived] class MkTraverseCons extends MkTraverseGeneric { implicit def mkTraverseHCons[F[_]](implicit F: IsHCons1[F, TraverseOrMk, MkTraverse]): MkTraverse[F] = new MkTraverse[F] { @@ -103,11 +103,11 @@ private[derived] abstract class MkTraverseCons extends MkTraverseGeneric { } } -private[derived] abstract class MkTraverseGeneric { +abstract private[derived] class MkTraverseGeneric { protected type TraverseOrMk[F[_]] = Traverse[F] OrElse MkTraverse[F] private[derived] def mkSafeTraverse[F[_], G[_]: Applicative, A, B]( - F: TraverseOrMk[F] + F: TraverseOrMk[F] )(fa: F[A])(f: A => Eval[G[B]]): Eval[G[F[B]]] = F.unify match { case mk: MkTraverse[F] => mk.safeTraverse(fa)(f) case other => other.traverse[λ[t => Eval[G[t]]], A, B](fa)(f)(Applicative[Eval].compose[G]) diff --git a/core/src/main/scala/cats/derived/util/fnGeneric.scala b/core/src/main/scala/cats/derived/util/fnGeneric.scala index b0cb2b5a..98afe399 100644 --- a/core/src/main/scala/cats/derived/util/fnGeneric.scala +++ b/core/src/main/scala/cats/derived/util/fnGeneric.scala @@ -13,8 +13,9 @@ object FnGeneric { type x type Aux[F[_], L <: HList] = FnGeneric[F] { type A = L } - implicit def instance[F[_], L <: HList]( - implicit toP: FnToProduct.Aux[F[x], L => x], fromP: FnFromProduct.Aux[L => x, F[x]] + implicit def instance[F[_], L <: HList](implicit + toP: FnToProduct.Aux[F[x], L => x], + fromP: FnFromProduct.Aux[L => x, F[x]] ): Aux[F, L] = new FnGeneric[F] { type A = L def to[B](f: F[B]): A => B = toP(f.asInstanceOf[F[x]]).asInstanceOf[A => B] diff --git a/core/src/main/scala/cats/derived/util/liftSome.scala b/core/src/main/scala/cats/derived/util/liftSome.scala index b3ac789e..da63115a 100644 --- a/core/src/main/scala/cats/derived/util/liftSome.scala +++ b/core/src/main/scala/cats/derived/util/liftSome.scala @@ -34,20 +34,21 @@ object LiftSome extends LiftSomeAbsent { def instances = HNil } - implicit def liftPresent[F[_], L, R <: Coproduct]( - implicit F: F[L], R: LiftSome[F, R] + implicit def liftPresent[F[_], L, R <: Coproduct](implicit + F: F[L], + R: LiftSome[F, R] ): Aux[F, L :+: R, F[L] :: R.Out] = new LiftSome[F, L :+: R] { type Out = F[L] :: R.Out val instances = F :: R.instances } } -private[util] abstract class LiftSomeAbsent { +abstract private[util] class LiftSomeAbsent { type Aux[F[_], C <: Coproduct, O <: HList] = LiftSome[F, C] { type Out = O } def apply[F[_], C <: Coproduct](lift: LiftSome[F, C]): Aux[F, C, lift.Out] = lift - implicit def liftAbsent[F[_], L, R <: Coproduct]( - implicit R: LiftSome[F, R] + implicit def liftAbsent[F[_], L, R <: Coproduct](implicit + R: LiftSome[F, R] ): Aux[F, L :+: R, R.Out] = new LiftSome[F, L :+: R] { type Out = R.Out def instances = R.instances diff --git a/core/src/main/scala/cats/lift/lift.scala b/core/src/main/scala/cats/lift/lift.scala index 704b56c6..7c19c312 100644 --- a/core/src/main/scala/cats/lift/lift.scala +++ b/core/src/main/scala/cats/lift/lift.scala @@ -1,5 +1,4 @@ -/** - * Originally adapted from shapeless-contrib +/** Originally adapted from shapeless-contrib * https://github.com/typelevel/shapeless-contrib/blob/v0.4/scalaz/main/scala/lift.scala */ package cats.lift @@ -16,14 +15,14 @@ trait LifterAux[G[_], I <: HList, R, GI <: HList] extends Serializable { object LifterAux { implicit def liftZero[G[_], R]: LifterAux[G, HNil, R, HNil] = new LifterAux[G, HNil, R, HNil] { - def apply(gf: G[HNil => R])(implicit G: Apply[G]) = _ => - G.map(gf)(_(HNil)) + def apply(gf: G[HNil => R])(implicit G: Apply[G]) = _ => G.map(gf)(_(HNil)) } - implicit def liftCons[G[_], H, T <: HList, R, GI <: HList](implicit tail: LifterAux[G, T, R, GI]): LifterAux[G, H :: T, R, G[H] :: GI] = new LifterAux[G, H :: T, R, G[H] :: GI] { - def apply(gf: G[(H :: T) => R])(implicit G: Apply[G]) = { - case gh :: gi => - tail(G.map2(gh, gf) { (h, f) => t => f(h :: t) })(G)(gi) + implicit def liftCons[G[_], H, T <: HList, R, GI <: HList](implicit + tail: LifterAux[G, T, R, GI] + ): LifterAux[G, H :: T, R, G[H] :: GI] = new LifterAux[G, H :: T, R, G[H] :: GI] { + def apply(gf: G[(H :: T) => R])(implicit G: Apply[G]) = { case gh :: gi => + tail(G.map2(gh, gf)((h, f) => t => f(h :: t)))(G)(gi) } } } @@ -31,14 +30,11 @@ object LifterAux { trait LiftsOps { implicit class ApplicativeOps[G[_]](instance: Applicative[G]) { - def liftA[F, R, I <: HList, GI <: HList, OF](f: F)( - implicit hlister: FnToProduct.Aux[F, I => R], - lifter: LifterAux[G, I, R, GI], - unhlister: FnFromProduct.Aux[GI => G[R], OF] + def liftA[F, R, I <: HList, GI <: HList, OF](f: F)(implicit + hlister: FnToProduct.Aux[F, I => R], + lifter: LifterAux[G, I, R, GI], + unhlister: FnFromProduct.Aux[GI => G[R], OF] ): OF = lifter(instance.pure(f.toProduct))(instance).fromProduct } } - - - diff --git a/core/src/main/scala/cats/replicateH/replicateH.scala b/core/src/main/scala/cats/replicateH/replicateH.scala index cd87e9fd..6528c048 100644 --- a/core/src/main/scala/cats/replicateH/replicateH.scala +++ b/core/src/main/scala/cats/replicateH/replicateH.scala @@ -13,8 +13,7 @@ sealed trait ReplicateH[F[_], N, A] extends Serializable { object ReplicateH { type Aux[F[_], N, A, LOut0] = ReplicateH[F, N, A] { type LOut = LOut0 } - implicit def mkReplicater[F[_], N, A, LIn <: HList, LOut <: HList]( - implicit + implicit def mkReplicater[F[_], N, A, LIn <: HList, LOut <: HList](implicit filler: Fill.Aux[N, F[A], LIn], sequencer: Sequencer.Aux[LIn, F, LOut] ): Aux[F, N, A, LOut] = @@ -25,14 +24,12 @@ object ReplicateH { } trait ReplicateHFunctions { - def replicateH[F[_], A](n: Nat, fa: F[A]) - (implicit replicater: ReplicateH[F, n.N, A]): replicater.Out = replicater(fa) + def replicateH[F[_], A](n: Nat, fa: F[A])(implicit replicater: ReplicateH[F, n.N, A]): replicater.Out = replicater(fa) } trait ReplicateHOps extends { implicit class withReplicateH[F[_], A](self: F[A]) { - def replicateH(n: Nat) - (implicit replicater: ReplicateH[F, n.N, A]): replicater.Out = replicater(self) + def replicateH(n: Nat)(implicit replicater: ReplicateH[F, n.N, A]): replicater.Out = replicater(self) } } diff --git a/core/src/main/scala/cats/sequence/sequence.scala b/core/src/main/scala/cats/sequence/sequence.scala index 5ddf076a..a02fdb28 100644 --- a/core/src/main/scala/cats/sequence/sequence.scala +++ b/core/src/main/scala/cats/sequence/sequence.scala @@ -21,25 +21,27 @@ trait Sequencer[L <: HList] extends Serializable { def apply(hl: L): Out } -private[sequence] abstract class MkHConsSequencerLowPrio { +abstract private[sequence] class MkHConsSequencerLowPrio { type Aux[L <: HList, F0[_], LOut0] = Sequencer[L] { type F[X] = F0[X] type LOut = LOut0 } - implicit def mkHConsSequencerForInvariant[F0[_], H, FT <: HList, T <: HList]( - implicit tailSequencer: Aux[FT, F0, T], F: InvariantSemigroupal[F0] + implicit def mkHConsSequencerForInvariant[F0[_], H, FT <: HList, T <: HList](implicit + tailSequencer: Aux[FT, F0, T], + F: InvariantSemigroupal[F0] ): Aux[F0[H] :: FT, F0, H :: T] = new Sequencer[F0[H] :: FT] { type F[X] = F0[X] type LOut = H :: T - def apply(hl: F[H] :: FT) = F.imap(F.product(hl.head, tailSequencer(hl.tail)))(p => p._1 :: p._2)(hl => (hl.head, hl.tail)) + def apply(hl: F[H] :: FT) = + F.imap(F.product(hl.head, tailSequencer(hl.tail)))(p => p._1 :: p._2)(hl => (hl.head, hl.tail)) } } -private[sequence] abstract class MkHNilSequencerLowPrio extends MkHConsSequencerLowPrio { - implicit def mkHNilSequencerForInvariant[F0[_]]( - implicit F: InvariantMonoidal[F0] +abstract private[sequence] class MkHNilSequencerLowPrio extends MkHConsSequencerLowPrio { + implicit def mkHNilSequencerForInvariant[F0[_]](implicit + F: InvariantMonoidal[F0] ): Sequencer.Aux[HNil, F0, HNil] = new Sequencer[HNil] { type F[X] = F0[X] type LOut = HNil @@ -47,8 +49,8 @@ private[sequence] abstract class MkHNilSequencerLowPrio extends MkHConsSequencer def apply(nil: HNil) = F.point(nil) } - implicit def mkSingletonSequencerForInvariant[F0[_], H]( - implicit F: Invariant[F0] + implicit def mkSingletonSequencerForInvariant[F0[_], H](implicit + F: Invariant[F0] ): Sequencer.Aux[F0[H] :: HNil, F0, H :: HNil] = new Sequencer[F0[H] :: HNil] { type F[X] = F0[X] type LOut = H :: HNil @@ -57,10 +59,11 @@ private[sequence] abstract class MkHNilSequencerLowPrio extends MkHConsSequencer } } -private[sequence] abstract class MkHConsSequencer extends MkHNilSequencerLowPrio { +abstract private[sequence] class MkHConsSequencer extends MkHNilSequencerLowPrio { - implicit def mkHConsSequencer[F0[_], H, FT <: HList, T <: HList]( - implicit tailSequencer: Aux[FT, F0, T], F: Apply[F0] + implicit def mkHConsSequencer[F0[_], H, FT <: HList, T <: HList](implicit + tailSequencer: Aux[FT, F0, T], + F: Apply[F0] ): Sequencer.Aux[F0[H] :: FT, F0, H :: T] = new Sequencer[F0[H] :: FT] { type F[X] = F0[X] type LOut = H :: T @@ -69,10 +72,9 @@ private[sequence] abstract class MkHConsSequencer extends MkHNilSequencerLowPrio } } - object Sequencer extends MkHConsSequencer { - implicit def mkHNilSequencer[F0[_]]( - implicit F: Applicative[F0] + implicit def mkHNilSequencer[F0[_]](implicit + F: Applicative[F0] ): Sequencer.Aux[HNil, F0, HNil] = new Sequencer[HNil] { type F[X] = F0[X] type LOut = HNil @@ -80,8 +82,8 @@ object Sequencer extends MkHConsSequencer { def apply(nil: HNil) = F.pure(nil) } - implicit def mkSingletonSequencer[F0[_], H]( - implicit F: Functor[F0] + implicit def mkSingletonSequencer[F0[_], H](implicit + F: Functor[F0] ): Sequencer.Aux[F0[H] :: HNil, F0, H :: HNil] = new Sequencer[F0[H] :: HNil] { type F[X] = F0[X] type LOut = H :: HNil @@ -97,15 +99,16 @@ trait RecordSequencer[L <: HList] extends Serializable { def apply(record: L): Out } -private[sequence] abstract class RecordSequencerInstanceLowPrio { - type Aux[L <: HList, Out0] = RecordSequencer[L] {type Out = Out0} +abstract private[sequence] class RecordSequencerInstanceLowPrio { + type Aux[L <: HList, Out0] = RecordSequencer[L] { type Out = Out0 } implicit def mkRecordSequencerForInvariant[R <: HList, K <: HList, V <: HList, F[_], VOut <: HList, ZOut <: HList]( - implicit unzip: UnzipFields.Aux[R, K, V], - valueSequencer: Sequencer.Aux[V, F, VOut], - F: Invariant[F], - zip: ZipWithKeys.Aux[K, VOut, ZOut], - values: Values.Aux[ZOut, VOut] + implicit + unzip: UnzipFields.Aux[R, K, V], + valueSequencer: Sequencer.Aux[V, F, VOut], + F: Invariant[F], + zip: ZipWithKeys.Aux[K, VOut, ZOut], + values: Values.Aux[ZOut, VOut] ): RecordSequencer.Aux[R, F[ZOut]] = new RecordSequencer[R] { type Out = F[zip.Out] @@ -115,11 +118,11 @@ private[sequence] abstract class RecordSequencerInstanceLowPrio { } object RecordSequencer extends RecordSequencerInstanceLowPrio { - implicit def mkRecordSequencer[R <: HList, K <: HList, V <: HList, F[_], VOut <: HList]( - implicit unzip: UnzipFields.Aux[R, K, V], - valueSequencer: Sequencer.Aux[V, F, VOut], - F: Functor[F], - zip: ZipWithKeys[K, VOut] + implicit def mkRecordSequencer[R <: HList, K <: HList, V <: HList, F[_], VOut <: HList](implicit + unzip: UnzipFields.Aux[R, K, V], + valueSequencer: Sequencer.Aux[V, F, VOut], + F: Functor[F], + zip: ZipWithKeys[K, VOut] ): RecordSequencer.Aux[R, F[zip.Out]] = new RecordSequencer[R] { type Out = F[zip.Out] @@ -133,16 +136,16 @@ trait GenericSequencer[L <: HList, T] extends Serializable { def apply(hl: L): Out } -private[sequence] abstract class GenericSequencerInstanceLowPrio { - type Aux[L <: HList, T, Out0] = GenericSequencer[L, T] {type Out = Out0} +abstract private[sequence] class GenericSequencerInstanceLowPrio { + type Aux[L <: HList, T, Out0] = GenericSequencer[L, T] { type Out = Out0 } - implicit def mkGenericSequencerForInvariant[L <: HList, T, SOut <: HList, FOut, LOut <: HList, F[_]]( - implicit recordSequencer: RecordSequencer.Aux[L, FOut], - eqv: FOut =:= F[SOut], - F: Invariant[F], - gen: LabelledGeneric.Aux[T, LOut], - align: Align[SOut, LOut], - unalign: Align[LOut, SOut] + implicit def mkGenericSequencerForInvariant[L <: HList, T, SOut <: HList, FOut, LOut <: HList, F[_]](implicit + recordSequencer: RecordSequencer.Aux[L, FOut], + eqv: FOut =:= F[SOut], + F: Invariant[F], + gen: LabelledGeneric.Aux[T, LOut], + align: Align[SOut, LOut], + unalign: Align[LOut, SOut] ): GenericSequencer.Aux[L, T, F[T]] = new GenericSequencer[L, T] { type Out = F[T] @@ -152,12 +155,12 @@ private[sequence] abstract class GenericSequencerInstanceLowPrio { } object GenericSequencer extends GenericSequencerInstanceLowPrio { - implicit def mkGenericSequencer[L <: HList, T, SOut <: HList, FOut, LOut <: HList, F[_]]( - implicit recordSequencer: RecordSequencer.Aux[L, FOut], - eqv: FOut =:= F[SOut], - F: Functor[F], - gen: LabelledGeneric.Aux[T, LOut], - align: Align[SOut, LOut] + implicit def mkGenericSequencer[L <: HList, T, SOut <: HList, FOut, LOut <: HList, F[_]](implicit + recordSequencer: RecordSequencer.Aux[L, FOut], + eqv: FOut =:= F[SOut], + F: Functor[F], + gen: LabelledGeneric.Aux[T, LOut], + align: Align[SOut, LOut] ): GenericSequencer.Aux[L, T, F[T]] = new GenericSequencer[L, T] { type Out = F[T] @@ -179,7 +182,7 @@ trait SequenceOps extends MkNonRecordOps { import SequenceOps._ - implicit def mkRecordOps[L <: HList : Keys](hl: L): RecordOps[L] = + implicit def mkRecordOps[L <: HList: Keys](hl: L): RecordOps[L] = new RecordOps(hl) object sequence extends ProductArgs { diff --git a/core/src/main/scala/cats/sequence/traverse.scala b/core/src/main/scala/cats/sequence/traverse.scala index c8c54e82..65f9a867 100644 --- a/core/src/main/scala/cats/sequence/traverse.scala +++ b/core/src/main/scala/cats/sequence/traverse.scala @@ -16,8 +16,9 @@ sealed trait Traverser[L <: HList, P] extends Serializable { object Traverser { type Aux[L <: HList, P, Out0] = Traverser[L, P] { type Out = Out0 } - implicit def mkTraverser[L <: HList, P, S <: HList]( - implicit mapper: Mapper.Aux[P, L, S], sequencer: Sequencer[S] + implicit def mkTraverser[L <: HList, P, S <: HList](implicit + mapper: Mapper.Aux[P, L, S], + sequencer: Sequencer[S] ): Aux[L, P, sequencer.Out] = new Traverser[L, P] { type Out = sequencer.Out def apply(hl: L): Out = sequencer(mapper(hl)) diff --git a/core/src/test/scala/cats/derived/KittensSuite.scala b/core/src/test/scala/cats/derived/KittensSuite.scala index 93d33238..a29e1952 100644 --- a/core/src/test/scala/cats/derived/KittensSuite.scala +++ b/core/src/test/scala/cats/derived/KittensSuite.scala @@ -23,19 +23,19 @@ import org.scalatest.matchers.should.Matchers import org.scalatestplus.scalacheck.Checkers import org.typelevel.discipline.scalatest.FunSuiteDiscipline -/** - * An opinionated stack of traits to improve consistency and reduce - * boilerplate in Kittens tests. Note that unlike the corresponding - * CatsSuite in the Cat project, this trait does not mix in any - * instances. - */ -abstract class KittensSuite extends AnyFunSuite - with Matchers - with Checkers - with FunSuiteDiscipline - with TestSettings - with AllSyntax - with StrictCatsEquality { +/** An opinionated stack of traits to improve consistency and reduce + * boilerplate in Kittens tests. Note that unlike the corresponding + * CatsSuite in the Cat project, this trait does not mix in any + * instances. + */ +abstract class KittensSuite + extends AnyFunSuite + with Matchers + with Checkers + with FunSuiteDiscipline + with TestSettings + with AllSyntax + with StrictCatsEquality { implicit override val generatorDrivenConfig: PropertyCheckConfiguration = checkConfiguration diff --git a/core/src/test/scala/cats/derived/adtdefns.scala b/core/src/test/scala/cats/derived/adtdefns.scala index 18b40ce5..fa638819 100644 --- a/core/src/test/scala/cats/derived/adtdefns.scala +++ b/core/src/test/scala/cats/derived/adtdefns.scala @@ -88,12 +88,12 @@ object TestDefns { case class Bivariant[A](run: A => Boolean, store: A) object Bivariant { - implicit def arbitrary[A: Arbitrary]: Arbitrary[Bivariant[A]] = Arbitrary( - for { - a <- Arbitrary.arbitrary[A] - f <- Arbitrary.arbitrary[Boolean].map(Function.const[Boolean, A]) - } yield Bivariant[A](f, a) - ) + implicit def arbitrary[A: Arbitrary]: Arbitrary[Bivariant[A]] = Arbitrary( + for { + a <- Arbitrary.arbitrary[A] + f <- Arbitrary.arbitrary[Boolean].map(Function.const[Boolean, A]) + } yield Bivariant[A](f, a) + ) } case class Pred[A](run: A => Boolean) @@ -280,121 +280,121 @@ object TestDefns { final case class ListFieldChild(c: Int) final case class Large( - bar1: String, - bar2: Int, - bar3: Boolean, - bar4: Large2, - bar5: List[String], - bar6: Set[Boolean], - bar7: Double, - bar8: Long, - bar9: Char, - bar10: Float, - bar11: String, - bar12: Map[String, Int], - bar13: Boolean, - bar14: Option[String], - bar15: List[String], - bar16: Set[Boolean], - bar17: Double, - bar18: Long, - bar19: Char, - bar20: Float + bar1: String, + bar2: Int, + bar3: Boolean, + bar4: Large2, + bar5: List[String], + bar6: Set[Boolean], + bar7: Double, + bar8: Long, + bar9: Char, + bar10: Float, + bar11: String, + bar12: Map[String, Int], + bar13: Boolean, + bar14: Option[String], + bar15: List[String], + bar16: Set[Boolean], + bar17: Double, + bar18: Long, + bar19: Char, + bar20: Float ) final case class Large2( - bar1: String, - bar2: Int, - bar3: Boolean, - bar4: Option[String], - bar5: List[String], - bar6: Set[Boolean], - bar7: Double, - bar8: Long, - bar9: Char, - bar10: Float, - bar11: String, - bar12: Map[String, Int], - bar13: Boolean, - bar14: Option[String], - bar15: List[String], - bar16: Set[Boolean], - bar17: Double, - bar18: Long, - bar19: Char, - bar20: Float, - bar21: String + bar1: String, + bar2: Int, + bar3: Boolean, + bar4: Option[String], + bar5: List[String], + bar6: Set[Boolean], + bar7: Double, + bar8: Long, + bar9: Char, + bar10: Float, + bar11: String, + bar12: Map[String, Int], + bar13: Boolean, + bar14: Option[String], + bar15: List[String], + bar16: Set[Boolean], + bar17: Double, + bar18: Long, + bar19: Char, + bar20: Float, + bar21: String ) final case class Large3( - bar1: String, - bar2: Int, - bar3: Boolean, - bar4: Option[String], - bar5: List[String], - bar6: Set[Boolean], - bar7: Double, - bar8: Long, - bar9: Char, - bar10: Float, - bar11: String, - bar12: Map[String, Int], - bar13: Boolean, - bar14: Option[String], - bar15: List[String], - bar16: Set[Boolean], - bar17: Double, - bar18: Long, - bar19: Char, - bar20: Float, - bar21: String + bar1: String, + bar2: Int, + bar3: Boolean, + bar4: Option[String], + bar5: List[String], + bar6: Set[Boolean], + bar7: Double, + bar8: Long, + bar9: Char, + bar10: Float, + bar11: String, + bar12: Map[String, Int], + bar13: Boolean, + bar14: Option[String], + bar15: List[String], + bar16: Set[Boolean], + bar17: Double, + bar18: Long, + bar19: Char, + bar20: Float, + bar21: String ) final case class Large4( - bar1: String, - bar2: Int, - bar3: Boolean, - bar4: Large5, - bar5: List[String], - bar6: List[Boolean], - bar7: Double, - bar8: Long, - bar9: Char, - bar10: Float, - bar11: String, - bar12: String, - bar13: Boolean, - bar14: Option[String], - bar15: List[String], - bar16: List[Boolean], - bar17: Double, - bar18: Long, - bar19: Char, - bar20: Float + bar1: String, + bar2: Int, + bar3: Boolean, + bar4: Large5, + bar5: List[String], + bar6: List[Boolean], + bar7: Double, + bar8: Long, + bar9: Char, + bar10: Float, + bar11: String, + bar12: String, + bar13: Boolean, + bar14: Option[String], + bar15: List[String], + bar16: List[Boolean], + bar17: Double, + bar18: Long, + bar19: Char, + bar20: Float ) final case class Large5( - bar1: String, - bar2: Int, - bar3: Boolean, - bar4: Option[String], - bar5: List[String], - bar6: List[Boolean], - bar7: Double, - bar8: Long, - bar9: Char, - bar10: Float, - bar11: String, - bar12: Int, - bar13: Boolean, - bar14: Option[String], - bar15: List[String], - bar16: List[Boolean], - bar17: Double, - bar18: Long, - bar19: Char, - bar20: Float, - bar21: String + bar1: String, + bar2: Int, + bar3: Boolean, + bar4: Option[String], + bar5: List[String], + bar6: List[Boolean], + bar7: Double, + bar8: Long, + bar9: Char, + bar10: Float, + bar11: String, + bar12: Int, + bar13: Boolean, + bar14: Option[String], + bar15: List[String], + bar16: List[Boolean], + bar17: Double, + bar18: Long, + bar19: Char, + bar20: Float, + bar21: String ) } diff --git a/core/src/test/scala/cats/derived/applicative.scala b/core/src/test/scala/cats/derived/applicative.scala index ce7a0874..d5725ebd 100644 --- a/core/src/test/scala/cats/derived/applicative.scala +++ b/core/src/test/scala/cats/derived/applicative.scala @@ -24,17 +24,20 @@ class ApplicativeSuite extends KittensSuite { import TestDefns._ import TestEqInstances._ - def testApplicative(context: String)( - implicit caseClassWOption: Applicative[CaseClassWOption], - optList: Applicative[OptList], - andInt: Applicative[AndInt], - interleaved: Applicative[Interleaved], - listBox: Applicative[ListBox] + def testApplicative(context: String)(implicit + caseClassWOption: Applicative[CaseClassWOption], + optList: Applicative[OptList], + andInt: Applicative[AndInt], + interleaved: Applicative[Interleaved], + listBox: Applicative[ListBox] ): Unit = { implicit val isoOptList: Isomorphisms[OptList] = Isomorphisms.invariant(optList) implicit val isoAndInt: Isomorphisms[AndInt] = Isomorphisms.invariant(andInt) implicit val isoListBox: Isomorphisms[ListBox] = Isomorphisms.invariant(listBox) - checkAll(s"$context.Applicative[CaseClassWOption]", ApplicativeTests[CaseClassWOption].applicative[Int, String, Long]) + checkAll( + s"$context.Applicative[CaseClassWOption]", + ApplicativeTests[CaseClassWOption].applicative[Int, String, Long] + ) checkAll(s"$context.Applicative[OptList]", ApplicativeTests[OptList].applicative[Int, String, Long]) checkAll(s"$context.Applicative[AndInt]", ApplicativeTests[AndInt].applicative[Int, String, Long]) checkAll(s"$context.Applicative[Interleaved]", ApplicativeTests[Interleaved].applicative[Int, String, Long]) diff --git a/core/src/test/scala/cats/derived/apply.scala b/core/src/test/scala/cats/derived/apply.scala index 504d4656..5590145b 100644 --- a/core/src/test/scala/cats/derived/apply.scala +++ b/core/src/test/scala/cats/derived/apply.scala @@ -24,12 +24,12 @@ class ApplySuite extends KittensSuite { import TestDefns._ import TestEqInstances._ - def testApply(context: String)( - implicit caseClassWOption: Apply[CaseClassWOption], - optList: Apply[OptList], - andInt: Apply[AndInt], - interleaved: Apply[Interleaved], - listBox: Apply[ListBox] + def testApply(context: String)(implicit + caseClassWOption: Apply[CaseClassWOption], + optList: Apply[OptList], + andInt: Apply[AndInt], + interleaved: Apply[Interleaved], + listBox: Apply[ListBox] ): Unit = { implicit val isoOptList: Isomorphisms[OptList] = Isomorphisms.invariant(optList) implicit val isoAndInt: Isomorphisms[AndInt] = Isomorphisms.invariant(andInt) diff --git a/core/src/test/scala/cats/derived/commutativeMonoid.scala b/core/src/test/scala/cats/derived/commutativeMonoid.scala index 32428379..67c8f163 100644 --- a/core/src/test/scala/cats/derived/commutativeMonoid.scala +++ b/core/src/test/scala/cats/derived/commutativeMonoid.scala @@ -26,15 +26,18 @@ class CommutativeMonoidSuite extends KittensSuite { import TestDefns._ import TestEqInstances._ - def testCommutativeMonoid(context: String)( - implicit commutativeFoo: CommutativeMonoid[CommutativeFoo], - recursive: CommutativeMonoid[Recursive], - box: CommutativeMonoid[Box[Mul]] + def testCommutativeMonoid(context: String)(implicit + commutativeFoo: CommutativeMonoid[CommutativeFoo], + recursive: CommutativeMonoid[Recursive], + box: CommutativeMonoid[Box[Mul]] ): Unit = { checkAll(s"$context.CommutativeMonoid[Foo]", CommutativeMonoidTests[CommutativeFoo].commutativeMonoid) checkAll(s"$context.CommutativeMonoid[Recursive]", CommutativeMonoidTests[Recursive].commutativeMonoid) checkAll(s"$context.CommutativeMonoid[Box[Mul]]", CommutativeMonoidTests[Box[Mul]].commutativeMonoid) - checkAll(s"$context.CommutativeMonoid is Serializable", SerializableTests.serializable(CommutativeMonoid[CommutativeFoo])) + checkAll( + s"$context.CommutativeMonoid is Serializable", + SerializableTests.serializable(CommutativeMonoid[CommutativeFoo]) + ) test(s"$context.CommutativeMonoid respects existing instances") { assert(box.empty == Box(Mul(1))) diff --git a/core/src/test/scala/cats/derived/commutativeSemigroup.scala b/core/src/test/scala/cats/derived/commutativeSemigroup.scala index effd9c15..3d03ac7a 100644 --- a/core/src/test/scala/cats/derived/commutativeSemigroup.scala +++ b/core/src/test/scala/cats/derived/commutativeSemigroup.scala @@ -26,15 +26,21 @@ class CommutativeSemigroupSuite extends KittensSuite { import TestDefns._ import TestEqInstances._ - def testCommutativeSemigroup(context: String)( - implicit foo: CommutativeSemigroup[CommutativeFoo], - recursive: CommutativeSemigroup[Recursive], - box: CommutativeSemigroup[Box[Mul]] + def testCommutativeSemigroup(context: String)(implicit + foo: CommutativeSemigroup[CommutativeFoo], + recursive: CommutativeSemigroup[Recursive], + box: CommutativeSemigroup[Box[Mul]] ): Unit = { - checkAll(s"$context.CommutativeSemigroup[CommutativeFoo]", CommutativeSemigroupTests[CommutativeFoo].commutativeSemigroup) + checkAll( + s"$context.CommutativeSemigroup[CommutativeFoo]", + CommutativeSemigroupTests[CommutativeFoo].commutativeSemigroup + ) checkAll(s"$context.CommutativeSemigroup[Recursive]", CommutativeSemigroupTests[Recursive].commutativeSemigroup) checkAll(s"$context.CommutativeSemigroup[Box[Mul]]", CommutativeSemigroupTests[Box[Mul]].commutativeSemigroup) - checkAll(s"$context.CommutativeSemigroup is Serializable", SerializableTests.serializable(CommutativeSemigroup[CommutativeFoo])) + checkAll( + s"$context.CommutativeSemigroup is Serializable", + SerializableTests.serializable(CommutativeSemigroup[CommutativeFoo]) + ) test(s"$context.CommutativeSemigroup respects existing instances") { assert(box.combine(Box(Mul(5)), Box(Mul(5))).content.value == 25) @@ -62,9 +68,11 @@ class CommutativeSemigroupSuite extends KittensSuite { object CommutativeSemigroupSuite { // can be removed once kittens depends on a version of cats that includes https://github.com/typelevel/cats/pull/2834 - implicit def commutativeSemigroupOption[A](implicit sa: CommutativeSemigroup[A]): CommutativeSemigroup[Option[A]] = new CommutativeSemigroup[Option[A]] { - def combine(x: Option[A], y: Option[A]): Option[A] = cats.instances.option.catsKernelStdMonoidForOption(sa).combine(x, y) - } + implicit def commutativeSemigroupOption[A](implicit sa: CommutativeSemigroup[A]): CommutativeSemigroup[Option[A]] = + new CommutativeSemigroup[Option[A]] { + def combine(x: Option[A], y: Option[A]): Option[A] = + cats.instances.option.catsKernelStdMonoidForOption(sa).combine(x, y) + } final case class Mul(value: Int) object Mul { diff --git a/core/src/test/scala/cats/derived/consk.scala b/core/src/test/scala/cats/derived/consk.scala index 7dc3f808..69096ff7 100644 --- a/core/src/test/scala/cats/derived/consk.scala +++ b/core/src/test/scala/cats/derived/consk.scala @@ -25,7 +25,7 @@ class ConsKSuite extends KittensSuite with ScalaCheckDrivenPropertyChecks { import ConsKSuite._ import TestDefns._ - def checkConsK[F[_], A : Arbitrary](nil: F[A])(fromSeq: Seq[A] => F[A])(implicit F: ConsK[F]): Unit = + def checkConsK[F[_], A: Arbitrary](nil: F[A])(fromSeq: Seq[A] => F[A])(implicit F: ConsK[F]): Unit = forAll((xs: List[A]) => assert(xs.foldRight(nil)(F.cons) == fromSeq(xs))) def testConsK(context: String)(implicit iList: ConsK[IList], snoc: ConsK[Snoc]): Unit = { diff --git a/core/src/test/scala/cats/derived/contravariant.scala b/core/src/test/scala/cats/derived/contravariant.scala index 24385efd..f77ed85f 100644 --- a/core/src/test/scala/cats/derived/contravariant.scala +++ b/core/src/test/scala/cats/derived/contravariant.scala @@ -25,22 +25,30 @@ class ContravariantSuite extends KittensSuite { import TestDefns._ import TestEqInstances._ - def testContravariant(context: String)( - implicit - optPred: Contravariant[OptPred], - treePred: Contravariant[TreePred], - listPred: Contravariant[ListPred], - genericAdtPred: Contravariant[GenericAdtPred], - liftSnocF: Contravariant[ListSnocF], - interleavedPred: Contravariant[InterleavedPred], - andCharPred: Contravariant[AndCharPred] + def testContravariant(context: String)(implicit + optPred: Contravariant[OptPred], + treePred: Contravariant[TreePred], + listPred: Contravariant[ListPred], + genericAdtPred: Contravariant[GenericAdtPred], + liftSnocF: Contravariant[ListSnocF], + interleavedPred: Contravariant[InterleavedPred], + andCharPred: Contravariant[AndCharPred] ): Unit = { checkAll(s"$context.Contravariant[OptPred]", ContravariantTests[OptPred].contravariant[MiniInt, String, Boolean]) checkAll(s"$context.Contravariant[TreePred]", ContravariantTests[TreePred].contravariant[MiniInt, String, Boolean]) checkAll(s"$context.Contravariant[ListPred]", ContravariantTests[ListPred].contravariant[MiniInt, String, Boolean]) - checkAll(s"$context.Contravariant[GenericAdtPred]", ContravariantTests[GenericAdtPred].contravariant[MiniInt, String, Boolean]) - checkAll(s"$context.Contravariant[InterleavedPred]", ContravariantTests[InterleavedPred].contravariant[MiniInt, String, Boolean]) - checkAll(s"$context.Contravariant[AndCharPred]", ContravariantTests[AndCharPred].contravariant[MiniInt, String, Boolean]) + checkAll( + s"$context.Contravariant[GenericAdtPred]", + ContravariantTests[GenericAdtPred].contravariant[MiniInt, String, Boolean] + ) + checkAll( + s"$context.Contravariant[InterleavedPred]", + ContravariantTests[InterleavedPred].contravariant[MiniInt, String, Boolean] + ) + checkAll( + s"$context.Contravariant[AndCharPred]", + ContravariantTests[AndCharPred].contravariant[MiniInt, String, Boolean] + ) checkAll(s"$context.Contravariant is Serializable", SerializableTests.serializable(Contravariant[TreePred])) test(s"$context.Contravariant.contramap is stack safe") { @@ -89,4 +97,3 @@ object ContravariantSuite { implicit val treePred: Contravariant[TreePred] = semiauto.contravariant } } - diff --git a/core/src/test/scala/cats/derived/empty.scala b/core/src/test/scala/cats/derived/empty.scala index a541bb4f..e6b47d28 100644 --- a/core/src/test/scala/cats/derived/empty.scala +++ b/core/src/test/scala/cats/derived/empty.scala @@ -25,15 +25,15 @@ class EmptySuite extends KittensSuite { import EmptySuite._ import TestDefns._ - def testEmpty(context: String)( - implicit foo: Empty[Foo], - outer: Empty[Outer], - interleaved: Empty[Interleaved[String]], - recursive: Empty[Recursive], - iList: Empty[IList[Dummy]], - snoc: Empty[Snoc[Dummy]], - box: Empty[Box[Mask]], - chain: Empty[Chain] + def testEmpty(context: String)(implicit + foo: Empty[Foo], + outer: Empty[Outer], + interleaved: Empty[Interleaved[String]], + recursive: Empty[Recursive], + iList: Empty[IList[Dummy]], + snoc: Empty[Snoc[Dummy]], + box: Empty[Box[Mask]], + chain: Empty[Chain] ): Unit = { test(s"$context.Empty[Foo]")(assert(foo.empty == Foo(0, None))) test(s"$context.Empty[Outer]")(assert(outer.empty == Outer(Inner(0)))) diff --git a/core/src/test/scala/cats/derived/emptyk.scala b/core/src/test/scala/cats/derived/emptyk.scala index dca9364b..c84bca30 100644 --- a/core/src/test/scala/cats/derived/emptyk.scala +++ b/core/src/test/scala/cats/derived/emptyk.scala @@ -26,12 +26,12 @@ class EmptyKSuite extends KittensSuite { import EmptyKSuite._ import TestDefns._ - def testEmptyK(context: String)( - implicit lOption: EmptyK[LOption], - pList: EmptyK[PList], - caseClassWOption: EmptyK[CaseClassWOption], - nelOption: EmptyK[NelOption], - boxColor: EmptyK[BoxColor] + def testEmptyK(context: String)(implicit + lOption: EmptyK[LOption], + pList: EmptyK[PList], + caseClassWOption: EmptyK[CaseClassWOption], + nelOption: EmptyK[NelOption], + boxColor: EmptyK[BoxColor] ): Unit = { test(s"$context.EmptyK[LOption]")(assert(lOption.empty == Nil)) test(s"$context.EmptyK[PList]")(assert(pList.empty == (Nil, Nil))) diff --git a/core/src/test/scala/cats/derived/eq.scala b/core/src/test/scala/cats/derived/eq.scala index 22947c30..6ab235bf 100644 --- a/core/src/test/scala/cats/derived/eq.scala +++ b/core/src/test/scala/cats/derived/eq.scala @@ -23,14 +23,14 @@ class EqSuite extends KittensSuite { import EqSuite._ import TestDefns._ - def testEq(context: String)( - implicit foo: Eq[Foo], - iList: Eq[IList[Int]], - inner: Eq[Inner], - outer: Eq[Outer], - interleaved: Eq[Interleaved[Int]], - tree: Eq[Tree[Int]], - recursive: Eq[Recursive] + def testEq(context: String)(implicit + foo: Eq[Foo], + iList: Eq[IList[Int]], + inner: Eq[Inner], + outer: Eq[Outer], + interleaved: Eq[Interleaved[Int]], + tree: Eq[Tree[Int]], + recursive: Eq[Recursive] ): Unit = { checkAll(s"$context.Eq[Foo]]", EqTests[Foo].eqv) checkAll(s"$context.Eq[IList[Int]]", EqTests[IList[Int]].eqv) diff --git a/core/src/test/scala/cats/derived/foldable.scala b/core/src/test/scala/cats/derived/foldable.scala index faccb712..42aaf61b 100644 --- a/core/src/test/scala/cats/derived/foldable.scala +++ b/core/src/test/scala/cats/derived/foldable.scala @@ -24,15 +24,15 @@ class FoldableSuite extends KittensSuite { import TestDefns._ import TestEqInstances._ - def testFoldable(context: String)( - implicit iList: Foldable[IList], - tree: Foldable[Tree], - genericAdt: Foldable[GenericAdt], - optList: Foldable[OptList], - listSnoc: Foldable[ListSnoc], - andChar: Foldable[AndChar], - interleaved: Foldable[Interleaved], - boxNel: Foldable[BoxNel] + def testFoldable(context: String)(implicit + iList: Foldable[IList], + tree: Foldable[Tree], + genericAdt: Foldable[GenericAdt], + optList: Foldable[OptList], + listSnoc: Foldable[ListSnoc], + andChar: Foldable[AndChar], + interleaved: Foldable[Interleaved], + boxNel: Foldable[BoxNel] ): Unit = { checkAll(s"$context.Foldable[IList]", FoldableTests[IList].foldable[Int, Long]) checkAll(s"$context.Foldable[Tree]", FoldableTests[Tree].foldable[Int, Long]) diff --git a/core/src/test/scala/cats/derived/functor.scala b/core/src/test/scala/cats/derived/functor.scala index 4bdb4e48..f7072ac0 100644 --- a/core/src/test/scala/cats/derived/functor.scala +++ b/core/src/test/scala/cats/derived/functor.scala @@ -27,15 +27,15 @@ class FunctorSuite extends KittensSuite { implicit val exhaustivePred: ExhaustiveCheck[Predicate[Boolean]] = ExhaustiveCheck.instance(List(_ => true, _ => false, identity, !_)) - def testFunctor(context: String)( - implicit iList: Functor[IList], - tree: Functor[Tree], - genericAdt: Functor[GenericAdt], - optList: Functor[OptList], - listSnoc: Functor[ListSnoc], - andChar: Functor[AndChar], - interleaved: Functor[Interleaved], - nestedPred: Functor[NestedPred] + def testFunctor(context: String)(implicit + iList: Functor[IList], + tree: Functor[Tree], + genericAdt: Functor[GenericAdt], + optList: Functor[OptList], + listSnoc: Functor[ListSnoc], + andChar: Functor[AndChar], + interleaved: Functor[Interleaved], + nestedPred: Functor[NestedPred] ): Unit = { checkAll(s"$context.Functor[IList]", FunctorTests[IList].functor[Int, String, Long]) checkAll(s"$context.Functor[Tree]", FunctorTests[Tree].functor[Int, String, Long]) diff --git a/core/src/test/scala/cats/derived/hash.scala b/core/src/test/scala/cats/derived/hash.scala index 8322bee5..4e74002c 100644 --- a/core/src/test/scala/cats/derived/hash.scala +++ b/core/src/test/scala/cats/derived/hash.scala @@ -7,13 +7,13 @@ class HashSuite extends KittensSuite { import HashSuite._ import TestDefns._ - def testHash(context: String)( - implicit iList: Hash[IList[Int]], - inner: Hash[Inner], - outer: Hash[Outer], - interleaved: Hash[Interleaved[Int]], - tree: Hash[Tree[Int]], - recursive: Hash[Recursive] + def testHash(context: String)(implicit + iList: Hash[IList[Int]], + inner: Hash[Inner], + outer: Hash[Outer], + interleaved: Hash[Interleaved[Int]], + tree: Hash[Tree[Int]], + recursive: Hash[Recursive] ): Unit = { checkAll(s"$context.Hash[IList[Int]]", HashTests[IList[Int]].hash) checkAll(s"$context.Hash[Inner]", HashTests[Inner].hash) diff --git a/core/src/test/scala/cats/derived/invariant.scala b/core/src/test/scala/cats/derived/invariant.scala index e9fe2920..c0e588d6 100644 --- a/core/src/test/scala/cats/derived/invariant.scala +++ b/core/src/test/scala/cats/derived/invariant.scala @@ -26,16 +26,15 @@ class InvariantSuite extends KittensSuite { import TestDefns._ import TestEqInstances._ - def testInvariant(context: String)( - implicit - tree: Invariant[TreeF], - genadt: Invariant[GenericAdtF], - ListFToInt: Invariant[ListFToInt], - listSnoc: Invariant[ListSnoc], - interleaved: Invariant[InterleavedF], - andCharF: Invariant[AndCharF], - bivariant: Invariant[Bivariant], - ilist: Invariant[IList] + def testInvariant(context: String)(implicit + tree: Invariant[TreeF], + genadt: Invariant[GenericAdtF], + ListFToInt: Invariant[ListFToInt], + listSnoc: Invariant[ListSnoc], + interleaved: Invariant[InterleavedF], + andCharF: Invariant[AndCharF], + bivariant: Invariant[Bivariant], + ilist: Invariant[IList] ): Unit = { checkAll(s"$context.Invariant[TreeF]", InvariantTests[TreeF].invariant[MiniInt, String, Boolean]) checkAll(s"$context.Invariant[GenAdtF]", InvariantTests[GenericAdtF].invariant[MiniInt, String, Boolean]) diff --git a/core/src/test/scala/cats/derived/iterable.scala b/core/src/test/scala/cats/derived/iterable.scala index 3be934e4..f1b2ceb3 100644 --- a/core/src/test/scala/cats/derived/iterable.scala +++ b/core/src/test/scala/cats/derived/iterable.scala @@ -34,7 +34,7 @@ class IterableSuite extends KittensSuite { assert(total == llargeTotal) val i2 = I.iterator - assert(i2 sameElements llarge.iterator) + assert(i2.sameElements(llarge.iterator)) } test("(T, T, T) => Iterable[T]") { diff --git a/core/src/test/scala/cats/derived/monoid.scala b/core/src/test/scala/cats/derived/monoid.scala index c8a26f14..a90f6e2e 100644 --- a/core/src/test/scala/cats/derived/monoid.scala +++ b/core/src/test/scala/cats/derived/monoid.scala @@ -25,11 +25,11 @@ class MonoidSuite extends KittensSuite { import TestDefns._ import TestEqInstances._ - def testMonoid(context: String)( - implicit foo: Monoid[Foo], - recursive: Monoid[Recursive], - interleaved: Monoid[Interleaved[Int]], - box: Monoid[Box[Mul]] + def testMonoid(context: String)(implicit + foo: Monoid[Foo], + recursive: Monoid[Recursive], + interleaved: Monoid[Interleaved[Int]], + box: Monoid[Box[Mul]] ): Unit = { checkAll(s"$context.Monoid[Foo]", MonoidTests[Foo].monoid) checkAll(s"$context.Monoid[Recursive]", MonoidTests[Recursive].monoid) diff --git a/core/src/test/scala/cats/derived/monoidk.scala b/core/src/test/scala/cats/derived/monoidk.scala index 7e89c0f6..3aa81af5 100644 --- a/core/src/test/scala/cats/derived/monoidk.scala +++ b/core/src/test/scala/cats/derived/monoidk.scala @@ -24,10 +24,10 @@ class MonoidKSuite extends KittensSuite { import TestDefns._ import TestEqInstances._ - def testMonoidK(context: String)( - implicit complexProduct: MonoidK[ComplexProduct], - caseClassWOption: MonoidK[CaseClassWOption], - boxMul: MonoidK[BoxMul] + def testMonoidK(context: String)(implicit + complexProduct: MonoidK[ComplexProduct], + caseClassWOption: MonoidK[CaseClassWOption], + boxMul: MonoidK[BoxMul] ): Unit = { checkAll(s"$context.MonoidK[ComplexProduct]", MonoidKTests[ComplexProduct].monoidK[Char]) checkAll(s"$context.MonoidK[CaseClassWOption]", MonoidKTests[CaseClassWOption].monoidK[Char]) diff --git a/core/src/test/scala/cats/derived/nonEmptyTraverse.scala b/core/src/test/scala/cats/derived/nonEmptyTraverse.scala index 9ec0185f..7ac32de8 100644 --- a/core/src/test/scala/cats/derived/nonEmptyTraverse.scala +++ b/core/src/test/scala/cats/derived/nonEmptyTraverse.scala @@ -26,13 +26,13 @@ class NonEmptyTraverseSuite extends KittensSuite { import TestDefns._ import TestEqInstances._ - def testReducible(context: String)( - implicit iCons: NonEmptyTraverse[ICons], - tree: NonEmptyTraverse[Tree], - nelSCons: NonEmptyTraverse[NelSCons], - nelAndOne: NonEmptyTraverse[NelAndOne], - listAndNel: NonEmptyTraverse[ListAndNel], - interleaved: NonEmptyTraverse[Interleaved] + def testReducible(context: String)(implicit + iCons: NonEmptyTraverse[ICons], + tree: NonEmptyTraverse[Tree], + nelSCons: NonEmptyTraverse[NelSCons], + nelAndOne: NonEmptyTraverse[NelAndOne], + listAndNel: NonEmptyTraverse[ListAndNel], + interleaved: NonEmptyTraverse[Interleaved] ): Unit = { checkAll( diff --git a/core/src/test/scala/cats/derived/order.scala b/core/src/test/scala/cats/derived/order.scala index 29185a73..5eef007a 100644 --- a/core/src/test/scala/cats/derived/order.scala +++ b/core/src/test/scala/cats/derived/order.scala @@ -23,12 +23,12 @@ class OrderSuite extends KittensSuite { import OrderSuite._ import TestDefns._ - def testOrder(context: String)( - implicit inner: Order[Inner], - outer: Order[Outer], - interleaved: Order[Interleaved[Int]], - recursive: Order[Recursive], - genericAdt: Order[GenericAdt[Int]] + def testOrder(context: String)(implicit + inner: Order[Inner], + outer: Order[Outer], + interleaved: Order[Interleaved[Int]], + recursive: Order[Recursive], + genericAdt: Order[GenericAdt[Int]] ): Unit = { checkAll(s"$context.Order[Inner]", OrderTests[Inner].order) checkAll(s"$context.Order[Outer]", OrderTests[Outer].order) diff --git a/core/src/test/scala/cats/derived/partialOrder.scala b/core/src/test/scala/cats/derived/partialOrder.scala index f9ee08ec..e6b2c335 100644 --- a/core/src/test/scala/cats/derived/partialOrder.scala +++ b/core/src/test/scala/cats/derived/partialOrder.scala @@ -23,14 +23,14 @@ class PartialOrderSuite extends KittensSuite { import PartialOrderSuite._ import TestDefns._ - def testPartialOrder(context: String)( - implicit iList: PartialOrder[IList[Int]], - inner: PartialOrder[Inner], - outer: PartialOrder[Outer], - interleaved: PartialOrder[Interleaved[Int]], - tree: PartialOrder[Tree[Int]], - recursive: PartialOrder[Recursive], - boxKeyValue: PartialOrder[Box[KeyValue]] + def testPartialOrder(context: String)(implicit + iList: PartialOrder[IList[Int]], + inner: PartialOrder[Inner], + outer: PartialOrder[Outer], + interleaved: PartialOrder[Interleaved[Int]], + tree: PartialOrder[Tree[Int]], + recursive: PartialOrder[Recursive], + boxKeyValue: PartialOrder[Box[KeyValue]] ): Unit = { checkAll(s"$context.PartialOrder[IList[Int]]", PartialOrderTests[IList[Int]].partialOrder) checkAll(s"$context.PartialOrder[Inner]", PartialOrderTests[Inner].partialOrder) diff --git a/core/src/test/scala/cats/derived/pure.scala b/core/src/test/scala/cats/derived/pure.scala index 843cf52b..4b3c5d75 100644 --- a/core/src/test/scala/cats/derived/pure.scala +++ b/core/src/test/scala/cats/derived/pure.scala @@ -26,13 +26,13 @@ class PureSuite extends KittensSuite { import PureSuite._ import TestDefns._ - def testPure(context: String)( - implicit lOption: Pure[LOption], - pList: Pure[PList], - caseClassWOption: Pure[CaseClassWOption], - nelOption: Pure[NelOption], - interleaved: Pure[Interleaved], - boxColor: Pure[BoxColor] + def testPure(context: String)(implicit + lOption: Pure[LOption], + pList: Pure[PList], + caseClassWOption: Pure[CaseClassWOption], + nelOption: Pure[NelOption], + interleaved: Pure[Interleaved], + boxColor: Pure[BoxColor] ): Unit = { test(s"$context.Pure[LOption]")(assert(lOption.pure(42) == Some(42) :: Nil)) test(s"$context.Pure[PList]")(assert(pList.pure("Scala") == ("Scala" :: Nil, "Scala" :: Nil))) diff --git a/core/src/test/scala/cats/derived/reducible.scala b/core/src/test/scala/cats/derived/reducible.scala index e1e5f07e..748d4d88 100644 --- a/core/src/test/scala/cats/derived/reducible.scala +++ b/core/src/test/scala/cats/derived/reducible.scala @@ -27,14 +27,14 @@ class ReducibleSuite extends KittensSuite { import TestDefns._ import TestEqInstances._ - def testReducible(context: String)( - implicit iCons: Reducible[ICons], - tree: Reducible[Tree], - nelSCons: Reducible[NelSCons], - nelAndOne: Reducible[NelAndOne], - listAndNel: Reducible[ListAndNel], - interleaved: Reducible[Interleaved], - boxZipper: Reducible[BoxZipper] + def testReducible(context: String)(implicit + iCons: Reducible[ICons], + tree: Reducible[Tree], + nelSCons: Reducible[NelSCons], + nelAndOne: Reducible[NelAndOne], + listAndNel: Reducible[ListAndNel], + interleaved: Reducible[Interleaved], + boxZipper: Reducible[BoxZipper] ): Unit = { checkAll(s"$context.Reducible[ICons]", ReducibleTests[ICons].reducible[Option, Int, Long]) checkAll(s"$context.Reducible[Tree]", ReducibleTests[Tree].reducible[Option, Int, Long]) diff --git a/core/src/test/scala/cats/derived/semigroup.scala b/core/src/test/scala/cats/derived/semigroup.scala index 01f2e534..8c429767 100644 --- a/core/src/test/scala/cats/derived/semigroup.scala +++ b/core/src/test/scala/cats/derived/semigroup.scala @@ -24,11 +24,11 @@ class SemigroupSuite extends KittensSuite { import TestDefns._ import TestEqInstances._ - def testSemigroup(context: String)( - implicit foo: Semigroup[Foo], - recursive: Semigroup[Recursive], - interleaved: Semigroup[Interleaved[Int]], - box: Semigroup[Box[Mul]] + def testSemigroup(context: String)(implicit + foo: Semigroup[Foo], + recursive: Semigroup[Recursive], + interleaved: Semigroup[Interleaved[Int]], + box: Semigroup[Box[Mul]] ): Unit = { checkAll(s"$context.Semigroup[Foo]", SemigroupTests[Foo].semigroup) checkAll(s"$context.Semigroup[Recursive]", SemigroupTests[Recursive].semigroup) diff --git a/core/src/test/scala/cats/derived/semigroupk.scala b/core/src/test/scala/cats/derived/semigroupk.scala index a43f98bb..769f0389 100644 --- a/core/src/test/scala/cats/derived/semigroupk.scala +++ b/core/src/test/scala/cats/derived/semigroupk.scala @@ -24,10 +24,10 @@ class SemigroupKSuite extends KittensSuite { import TestDefns._ import TestEqInstances._ - def testSemigroupK(context: String)( - implicit complexProduct: SemigroupK[ComplexProduct], - caseClassWOption: SemigroupK[CaseClassWOption], - boxMul: SemigroupK[BoxMul] + def testSemigroupK(context: String)(implicit + complexProduct: SemigroupK[ComplexProduct], + caseClassWOption: SemigroupK[CaseClassWOption], + boxMul: SemigroupK[BoxMul] ): Unit = { checkAll(s"$context.SemigroupK[ComplexProduct]", SemigroupKTests[ComplexProduct].semigroupK[Char]) checkAll(s"$context.SemigroupK[CaseClassWOption]", SemigroupKTests[CaseClassWOption].semigroupK[Char]) diff --git a/core/src/test/scala/cats/derived/show.scala b/core/src/test/scala/cats/derived/show.scala index 3aa0ab62..ba544474 100644 --- a/core/src/test/scala/cats/derived/show.scala +++ b/core/src/test/scala/cats/derived/show.scala @@ -7,15 +7,15 @@ class ShowSuite extends KittensSuite { import ShowSuite._ import TestDefns._ - def testShow(context: String)( - implicit foo: Show[Foo], - outer: Show[Outer], - intTree: Show[IntTree], - genericAdt: Show[GenericAdt[Int]], - people: Show[People], - listField: Show[ListField], - interleaved: Show[Interleaved[Int]], - boxBogus: Show[Box[Bogus]] + def testShow(context: String)(implicit + foo: Show[Foo], + outer: Show[Outer], + intTree: Show[IntTree], + genericAdt: Show[GenericAdt[Int]], + people: Show[People], + listField: Show[ListField], + interleaved: Show[Interleaved[Int]], + boxBogus: Show[Box[Bogus]] ): Unit = { checkAll(s"$context.Show is Serializable", SerializableTests.serializable(Show[IntTree])) @@ -33,7 +33,8 @@ class ShowSuite extends KittensSuite { test(s"$context.Show[IntTree]") { val value: IntTree = IntNode(IntLeaf(1), IntNode(IntNode(IntLeaf(2), IntLeaf(3)), IntLeaf(4))) - val shown = "IntNode(l = IntLeaf(t = 1), r = IntNode(l = IntNode(l = IntLeaf(t = 2), r = IntLeaf(t = 3)), r = IntLeaf(t = 4)))" + val shown = + "IntNode(l = IntLeaf(t = 1), r = IntNode(l = IntNode(l = IntLeaf(t = 2), r = IntLeaf(t = 3)), r = IntLeaf(t = 4)))" assert(value.show == shown) } @@ -45,7 +46,8 @@ class ShowSuite extends KittensSuite { test(s"$context.Show[People]") { val value = People("Kai", ContactInfo("303-123-4567", Address("123 1st St", "New York", "NY"))) - val shown = "People(name = Kai, contactInfo = ContactInfo(phoneNumber = 303-123-4567, address = 123 1st St New York NY))" + val shown = + "People(name = Kai, contactInfo = ContactInfo(phoneNumber = 303-123-4567, address = 123 1st St New York NY))" assert(value.show == shown) } diff --git a/core/src/test/scala/cats/derived/showPretty.scala b/core/src/test/scala/cats/derived/showPretty.scala index 111fd49f..005271fb 100644 --- a/core/src/test/scala/cats/derived/showPretty.scala +++ b/core/src/test/scala/cats/derived/showPretty.scala @@ -7,15 +7,15 @@ class ShowPrettySuite extends KittensSuite { import ShowPrettySuite._ import TestDefns._ - def testShowPretty(context: String)( - implicit foo: ShowPretty[Foo], - outer: ShowPretty[Outer], - intTree: ShowPretty[IntTree], - genericAdt: ShowPretty[GenericAdt[Int]], - people: ShowPretty[People], - listField: ShowPretty[ListField], - interleaved: ShowPretty[Interleaved[Int]], - boxBogus: ShowPretty[Box[Bogus]] + def testShowPretty(context: String)(implicit + foo: ShowPretty[Foo], + outer: ShowPretty[Outer], + intTree: ShowPretty[IntTree], + genericAdt: ShowPretty[GenericAdt[Int]], + people: ShowPretty[People], + listField: ShowPretty[ListField], + interleaved: ShowPretty[Interleaved[Int]], + boxBogus: ShowPretty[Box[Bogus]] ): Unit = { checkAll(s"$context.ShowPretty is Serializable", SerializableTests.serializable(ShowPretty[IntTree])) diff --git a/core/src/test/scala/cats/derived/traverse.scala b/core/src/test/scala/cats/derived/traverse.scala index 6091e680..4cc45f69 100644 --- a/core/src/test/scala/cats/derived/traverse.scala +++ b/core/src/test/scala/cats/derived/traverse.scala @@ -7,22 +7,31 @@ class TraverseSuite extends KittensSuite { import TestEqInstances._ import TraverseSuite._ - def testTraverse(context: String)( - implicit iList: Traverse[IList], - tree: Traverse[Tree], - genericAdt: Traverse[GenericAdt], - optList: Traverse[OptList], - listSnoc: Traverse[ListSnoc], - andChar: Traverse[AndChar], - interleaved: Traverse[Interleaved] + def testTraverse(context: String)(implicit + iList: Traverse[IList], + tree: Traverse[Tree], + genericAdt: Traverse[GenericAdt], + optList: Traverse[OptList], + listSnoc: Traverse[ListSnoc], + andChar: Traverse[AndChar], + interleaved: Traverse[Interleaved] ): Unit = { checkAll(s"$context.Traverse[IList]", TraverseTests[IList].traverse[Int, Double, String, Long, Option, Option]) checkAll(s"$context.Traverse[Tree]", TraverseTests[Tree].traverse[Int, Double, String, Long, Option, Option]) - checkAll(s"$context.Traverse[GenericAdt]", TraverseTests[GenericAdt].traverse[Int, Double, String, Long, Option, Option]) + checkAll( + s"$context.Traverse[GenericAdt]", + TraverseTests[GenericAdt].traverse[Int, Double, String, Long, Option, Option] + ) checkAll(s"$context.Traverse[OptList]", TraverseTests[OptList].traverse[Int, Double, String, Long, Option, Option]) - checkAll(s"$context.Traverse[ListSnoc]", TraverseTests[ListSnoc].traverse[Int, Double, String, Long, Option, Option]) + checkAll( + s"$context.Traverse[ListSnoc]", + TraverseTests[ListSnoc].traverse[Int, Double, String, Long, Option, Option] + ) checkAll(s"$context.Traverse[AndChar]", TraverseTests[AndChar].traverse[Int, Double, String, Long, Option, Option]) - checkAll(s"$context.Traverse[Interleaved]", TraverseTests[Interleaved].traverse[Int, Double, String, Long, Option, Option]) + checkAll( + s"$context.Traverse[Interleaved]", + TraverseTests[Interleaved].traverse[Int, Double, String, Long, Option, Option] + ) checkAll(s"$context.Traverse is Serializable", SerializableTests.serializable(Traverse[Tree])) val n = 10000 diff --git a/core/src/test/scala/cats/replicateH/ReplicateHSuite.scala b/core/src/test/scala/cats/replicateH/ReplicateHSuite.scala index 0ee1d51a..8b2b211e 100644 --- a/core/src/test/scala/cats/replicateH/ReplicateHSuite.scala +++ b/core/src/test/scala/cats/replicateH/ReplicateHSuite.scala @@ -7,15 +7,13 @@ import shapeless._ import cats.derived._ import org.scalacheck.Prop._ - class ReplicateHSuite extends KittensSuite { - val getAndInc: State[Int, Int] = State { i => (i + 1, i)} + val getAndInc: State[Int, Int] = State(i => (i + 1, i)) - test("replicating state example")( - check { - val getAndInc5: State[Int, Int :: Int :: Int :: Int :: Int :: HNil] = getAndInc.replicateH(5) - getAndInc5.run(0).value ?= (5, 0 :: 1 :: 2 :: 3 :: 4 :: HNil) - }) + test("replicating state example")(check { + val getAndInc5: State[Int, Int :: Int :: Int :: Int :: Int :: HNil] = getAndInc.replicateH(5) + getAndInc5.run(0).value ?= (5, 0 :: 1 :: 2 :: 3 :: 4 :: HNil) + }) test("replicating arbitrary state")(check { forAll { (initial: Int, x: State[Int, String]) => @@ -47,19 +45,17 @@ class ReplicateHSuite extends KittensSuite { } }) - test("replicate 0 state")( - check { - val getAndInc0: State[Int, HNil] = getAndInc.replicateH(0) - forAll { (initial: Int) => - getAndInc0.run(initial).value ?= (initial, HNil) - } - }) + test("replicate 0 state")(check { + val getAndInc0: State[Int, HNil] = getAndInc.replicateH(0) + forAll { (initial: Int) => + getAndInc0.run(initial).value ?= (initial, HNil) + } + }) - test("replicate 1 state")( - check { - val getAndInc1: State[Int, Int :: HNil] = getAndInc.replicateH(1) - forAll { (initial: Int) => - getAndInc1.run(initial).value ?= (initial + 1, initial :: HNil) - } - }) + test("replicate 1 state")(check { + val getAndInc1: State[Int, Int :: HNil] = getAndInc.replicateH(1) + forAll { (initial: Int) => + getAndInc1.run(initial).value ?= (initial + 1, initial :: HNil) + } + }) } diff --git a/core/src/test/scala/cats/sequence/SequenceSuite.scala b/core/src/test/scala/cats/sequence/SequenceSuite.scala index c04811d0..bc8e3ee2 100644 --- a/core/src/test/scala/cats/sequence/SequenceSuite.scala +++ b/core/src/test/scala/cats/sequence/SequenceSuite.scala @@ -17,7 +17,7 @@ class SequenceSuite extends KittensSuite { test("sequencing Option")(check { forAll { (x: Option[Int], y: Option[String], z: Option[Float]) => - val expected = (x, y, z) mapN (_ :: _ :: _ :: HNil) + val expected = (x, y, z).mapN(_ :: _ :: _ :: HNil) (x :: y :: z :: HNil).sequence == expected } }) @@ -27,24 +27,30 @@ class SequenceSuite extends KittensSuite { // However, we can explicitly grab the Sequencer for Option and use it. check { implicitly[Sequencer.Aux[HNil, Option, HNil]].apply(HNil) contains HNil - }) + } + ) test("sequencing Either")(check { forAll { (x: Either[String, Int], y: Either[String, String], z: Either[String, Float]) => - val expected = (x, y, z) mapN (_ :: _ :: _ :: HNil) + val expected = (x, y, z).mapN(_ :: _ :: _ :: HNil) (x :: y :: z :: HNil).sequence == expected } }) // note: using the ValidationNel type alias here breaks the implicit search test("sequencing ValidatedNel")(check { - forAll { (x: Validated[NonEmptyList[String], Int], y: Validated[NonEmptyList[String], String], z: Validated[NonEmptyList[String], Float]) => - val expected = (x, y, z) mapN (_ :: _ :: _ :: HNil) - sequence(x, y, z) == expected + forAll { + ( + x: Validated[NonEmptyList[String], Int], + y: Validated[NonEmptyList[String], String], + z: Validated[NonEmptyList[String], Float] + ) => + val expected = (x, y, z).mapN(_ :: _ :: _ :: HNil) + sequence(x, y, z) == expected } }) - test("sequencing Function"){ + test("sequencing Function") { val f1 = (_: String).length val f2 = (_: String).reverse val f3 = (_: String).toDouble @@ -52,18 +58,18 @@ class SequenceSuite extends KittensSuite { assert(f("42.0") == 4 :: "0.24" :: 42.0 :: HNil) } - test("sequencing Semigroup"){ + test("sequencing Semigroup") { val si = Semigroup[Int] val ss = Semigroup[String] val sis = (si :: ss :: HNil).sequence check { - forAll {(i1: Int, s1: String, i2: Int, s2: String) => + forAll { (i1: Int, s1: String, i2: Int, s2: String) => sis.combine(i1 :: s1 :: HNil, i2 :: s2 :: HNil) == si.combine(i1, i2) :: ss.combine(s1, s2) :: HNil } } } - test("sequencing Function using ProductArgs"){ + test("sequencing Function using ProductArgs") { val f1 = (_: String).length val f2 = (_: String).reverse val f3 = (_: String).toDouble @@ -72,9 +78,9 @@ class SequenceSuite extends KittensSuite { } test("sequencing Klesilis through ProductArgs") { - val f1 = ((_: String).length) andThen Option.apply - val f2 = ((_: String).reverse) andThen Option.apply - val f3 = ((_: String).toDouble) andThen Option.apply + val f1 = ((_: String).length).andThen(Option.apply) + val f2 = ((_: String).reverse).andThen(Option.apply) + val f3 = ((_: String).toDouble).andThen(Option.apply) val f = sequence(Kleisli(f1), Kleisli(f2), Kleisli(f3)) val expected = Some((Symbol("a") ->> 4) :: (Symbol("b") ->> "0.24") :: (Symbol("c") ->> 42.0) :: HNil) assert(f.run("42.0") == expected) @@ -82,24 +88,33 @@ class SequenceSuite extends KittensSuite { test("sequencing record of Option")(check { forAll { (x: Option[Int], y: Option[String], z: Option[Float]) => - val expected = for (a <- x; b <- y; c <- z) - yield ("a" ->> a) :: ("b" ->> b) :: ("c" ->> c) :: HNil + val expected = for { + a <- x + b <- y + c <- z + } yield ("a" ->> a) :: ("b" ->> b) :: ("c" ->> c) :: HNil (("a" ->> x) :: ("b" ->> y) :: ("c" ->> z) :: HNil).sequence == expected } }) test("sequencing record of Option using RecordArgs")(check { forAll { (x: Option[Int], y: Option[String], z: Option[Float]) => - val expected = for (a <- x; b <- y; c <- z) - yield ("a" ->> a) :: ("b" ->> b) :: ("c" ->> c) :: HNil + val expected = for { + a <- x + b <- y + c <- z + } yield ("a" ->> a) :: ("b" ->> b) :: ("c" ->> c) :: HNil sequenceRecord(a = x, b = y, c = z) == expected } }) test("sequencing record of Either")(check { forAll { (x: Either[String, Int], y: Either[String, String], z: Either[String, Float]) => - val expected = for (a <- x; b <- y; c <- z) - yield ("a" ->> a) :: ("b" ->> b) :: ("c" ->> c) :: HNil + val expected = for { + a <- x + b <- y + c <- z + } yield ("a" ->> a) :: ("b" ->> b) :: ("c" ->> c) :: HNil (("a" ->> x) :: ("b" ->> y) :: ("c" ->> z) :: HNil).sequence == expected } }) @@ -114,20 +129,20 @@ class SequenceSuite extends KittensSuite { } test("sequencing record of Kleisli through RecordArgs") { - val f1 = ((_: String).length) andThen Option.apply - val f2 = ((_: String).reverse) andThen Option.apply - val f3 = ((_: String).toDouble) andThen Option.apply + val f1 = ((_: String).length).andThen(Option.apply) + val f2 = ((_: String).reverse).andThen(Option.apply) + val f3 = ((_: String).toDouble).andThen(Option.apply) val f = sequenceRecord(a = Kleisli(f1), b = Kleisli(f2), c = Kleisli(f3)) val expected = Some(("a" ->> 4) :: ("b" ->> "0.24") :: ("c" ->> 42.0) :: HNil) assert(f.run("42.0") == expected) } - test("sequencing record of Semigroup through RecordArgs"){ + test("sequencing record of Semigroup through RecordArgs") { val si = Semigroup[Int] val ss = Semigroup[String] val sis = sequenceRecord(i = si, s = ss) check { - forAll {(i1: Int, s1: String, i2: Int, s2: String) => + forAll { (i1: Int, s1: String, i2: Int, s2: String) => val rec1 = Record(i = i1, s = s1) val rec2 = Record(i = i2, s = s2) sis.combine(rec1, rec2) == ("i" ->> si.combine(i1, i2)) :: ("s" ->> ss.combine(s1, s2)) :: HNil @@ -140,7 +155,7 @@ class SequenceSuite extends KittensSuite { test("sequence gen for Option")(check { forAll { (x: Option[Int], y: Option[String], z: Option[Float]) => val myGen = sequenceGeneric[MyCase] - val expected = (x, y, z) mapN MyCase.apply + val expected = (x, y, z).mapN(MyCase.apply) myGen(a = x, b = y, c = z) == expected } }) @@ -148,7 +163,7 @@ class SequenceSuite extends KittensSuite { test("sequence gen with different sort")(check { forAll { (x: Option[Int], y: Option[String], z: Option[Float]) => val myGen = sequenceGeneric[MyCase] - val expected = (x, y, z) mapN MyCase.apply + val expected = (x, y, z).mapN(MyCase.apply) myGen(b = y, a = x, c = z) == expected } }) @@ -156,7 +171,7 @@ class SequenceSuite extends KittensSuite { test("sequence gen for Either")(check { forAll { (x: Either[String, Int], y: Either[String, String], z: Either[String, Float]) => val myGen = sequenceGeneric[MyCase] - val expected = (x, y, z) mapN MyCase.apply + val expected = (x, y, z).mapN(MyCase.apply) myGen(a = x, b = y, c = z) == expected } }) @@ -171,23 +186,27 @@ class SequenceSuite extends KittensSuite { } test("sequence gen for Klesili") { - val f1 = ((_: String).length) andThen Option.apply - val f2 = ((_: String).reverse) andThen Option.apply - val f3 = ((_: String).toFloat) andThen Option.apply + val f1 = ((_: String).length).andThen(Option.apply) + val f2 = ((_: String).reverse).andThen(Option.apply) + val f3 = ((_: String).toFloat).andThen(Option.apply) val myGen = sequenceGeneric[MyCase] val f = myGen(a = Kleisli(f1), b = Kleisli(f2), c = Kleisli(f3)) assert(f.run("42.0") == Some(MyCase(4, "0.24", 42.0f))) } - test("sequencing gen for Semigroup"){ + test("sequencing gen for Semigroup") { val si = Semigroup[Int] val ss = Semigroup[String] val sf = Semigroup[Float] val myGen = sequenceGeneric[MyCase] val sm = myGen(a = si, b = ss, c = sf) check { - forAll {(i1: Int, s1: String, f1: Float, i2: Int, s2: String, f2: Float) => - sm.combine(MyCase(i1, s1, f1), MyCase(i2, s2, f2)) == MyCase(si.combine(i1, i2), ss.combine(s1, s2), sf.combine(f1, f2)) + forAll { (i1: Int, s1: String, f1: Float, i2: Int, s2: String, f2: Float) => + sm.combine(MyCase(i1, s1, f1), MyCase(i2, s2, f2)) == MyCase( + si.combine(i1, i2), + ss.combine(s1, s2), + sf.combine(f1, f2) + ) } } } diff --git a/project/plugins.sbt b/project/plugins.sbt index 7062fc3a..8063b82d 100644 --- a/project/plugins.sbt +++ b/project/plugins.sbt @@ -1,8 +1,9 @@ -addSbtPlugin("com.github.gseitz" % "sbt-release" % "1.0.13") -addSbtPlugin("com.jsuereth" % "sbt-pgp" % "2.0.1") -addSbtPlugin("com.typesafe.sbt" % "sbt-git" % "1.0.0") -addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.3.0") -addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "3.9.4") -addSbtPlugin("com.thoughtworks.sbt-api-mappings" % "sbt-api-mappings" % "3.0.0") -addSbtPlugin("org.portable-scala" % "sbt-scalajs-crossproject" % "1.0.0") -addSbtPlugin("com.typesafe" % "sbt-mima-plugin" % "0.8.1") +addSbtPlugin("com.github.gseitz" % "sbt-release" % "1.0.13") +addSbtPlugin("com.jsuereth" % "sbt-pgp" % "2.0.1") +addSbtPlugin("com.typesafe.sbt" % "sbt-git" % "1.0.0") +addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.3.0") +addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "3.9.4") +addSbtPlugin("com.thoughtworks.sbt-api-mappings" % "sbt-api-mappings" % "3.0.0") +addSbtPlugin("org.portable-scala" % "sbt-scalajs-crossproject" % "1.0.0") +addSbtPlugin("com.typesafe" % "sbt-mima-plugin" % "0.8.1") +addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.4.2")