Merge remote-tracking branch 'origin/master' into 373-traversable-laws

zalbia · zalbia · commit fc8bf61e07c0 · 2020-11-30T18:53:29.000+08:00
diff --git a/.scalafix.conf b/.scalafix.conf
@@ -20,11 +20,11 @@ Disable {
 OrganizeImports {
   expandRelative = true
   groupedImports = Merge
+  # IntelliJ IDEA's order so that they don't fight each other
   groups = [
     "java."
-    "scala."
-    "zio."
     "*"
+    "scala."
   ]
 }
 
diff --git a/build.sbt b/build.sbt
@@ -145,7 +145,7 @@ lazy val benchmarks = project.module
     scalacOptions -= "-Xfatal-warnings",
     libraryDependencies ++= Seq(
       "dev.zio" %% "zio" % zioVersion,
-      ("org.typelevel" %% "cats-core" % "2.2.0") match {
+      ("org.typelevel" %% "cats-core" % "2.3.0") match {
         case cats if isDotty.value => cats.withDottyCompat(scalaVersion.value)
         case cats                  => cats
       }
diff --git a/core/jvm/src/test/scala/zio/prelude/AssociativeParIterableSpec.scala b/core/jvm/src/test/scala/zio/prelude/AssociativeParIterableSpec.scala
@@ -1,11 +1,10 @@
 package zio.prelude
 
+import com.github.ghik.silencer.silent
 import zio.blocking.Blocking
 import zio.prelude.newtypes.Sum
 import zio.test._
 
-import com.github.ghik.silencer.silent
-
 @silent
 object AssociativeParIterableSpec extends DefaultRunnableSpec {
   private val ParallelCollectionCompatibility = {
diff --git a/core/jvm/src/test/scala/zio/prelude/CommutativeEitherSpec.scala b/core/jvm/src/test/scala/zio/prelude/CommutativeEitherSpec.scala
@@ -1,10 +1,10 @@
 package zio.prelude
 
-import scala.concurrent.{ Future, blocking }
-
 import zio.ZIO
 import zio.test._
 
+import scala.concurrent.{ Future, blocking }
+
 object CommutativeEitherSpec extends DefaultRunnableSpec {
 
   def spec: Spec[Any, TestFailure[Throwable], TestSuccess] =
diff --git a/core/jvm/src/test/scala/zio/prelude/IdentityParIterableSpec.scala b/core/jvm/src/test/scala/zio/prelude/IdentityParIterableSpec.scala
@@ -1,11 +1,10 @@
 package zio.prelude
 
+import com.github.ghik.silencer.silent
 import zio.blocking.Blocking
 import zio.prelude.newtypes.Sum
 import zio.test._
 
-import com.github.ghik.silencer.silent
-
 @silent
 object IdentityParIterableSpec extends DefaultRunnableSpec {
   private val ParallelCollectionCompatibility = {
diff --git a/core/shared/src/main/scala/zio/prelude/Associative.scala b/core/shared/src/main/scala/zio/prelude/Associative.scala
@@ -1,13 +1,13 @@
 package zio.prelude
 
-import scala.annotation.tailrec
-
 import zio.prelude.coherent.AssociativeEqual
 import zio.prelude.newtypes.{ And, First, Last, Max, Min, Or, Prod, Sum }
 import zio.test.TestResult
 import zio.test.laws.{ Lawful, Laws }
 import zio.{ Chunk, NonEmptyChunk }
 
+import scala.annotation.tailrec
+
 /**
  * The `Associative[A]` type class describes an associative binary operator
  * for a type `A`. For example, addition for integers, and string
diff --git a/core/shared/src/main/scala/zio/prelude/AssociativeBoth.scala b/core/shared/src/main/scala/zio/prelude/AssociativeBoth.scala
@@ -1,9 +1,5 @@
 package zio.prelude
 
-import scala.annotation.implicitNotFound
-import scala.concurrent.Future
-import scala.util.{ Success, Try }
-
 import zio._
 import zio.prelude.coherent.AssociativeBothDeriveEqualInvariant
 import zio.prelude.newtypes.{ AndF, Failure, OrF }
@@ -12,6 +8,10 @@ import zio.stream.{ ZSink, ZStream }
 import zio.test.TestResult
 import zio.test.laws._
 
+import scala.annotation.implicitNotFound
+import scala.concurrent.Future
+import scala.util.{ Success, Try }
+
 /**
  * An associative binary operator that combines two values of types `F[A]`
  * and `F[B]` to produce an `F[(A, B)]`.
diff --git a/core/shared/src/main/scala/zio/prelude/AssociativeEither.scala b/core/shared/src/main/scala/zio/prelude/AssociativeEither.scala
@@ -1,16 +1,16 @@
 package zio.prelude
 
-import scala.annotation.implicitNotFound
-import scala.concurrent.{ ExecutionContext, Future }
-import scala.util.Try
-
 import zio._
 import zio.prelude.coherent.AssociativeEitherDeriveEqualInvariant
 import zio.prelude.newtypes.Failure
 import zio.stream.ZStream
 import zio.test.TestResult
 import zio.test.laws._
 
+import scala.annotation.implicitNotFound
+import scala.concurrent.{ ExecutionContext, Future }
+import scala.util.Try
+
 /**
  * An associative binary operator that combines two values of types `F[A]`
  * and `F[B]` to produce an `F[Either[A, B]]`.
diff --git a/core/shared/src/main/scala/zio/prelude/AssociativeFlatten.scala b/core/shared/src/main/scala/zio/prelude/AssociativeFlatten.scala
@@ -1,15 +1,15 @@
 package zio.prelude
 
-import scala.annotation.implicitNotFound
-import scala.concurrent.Future
-import scala.util.{ Success, Try }
-
 import zio._
 import zio.prelude.coherent.AssociativeFlattenCovariantDeriveEqual
 import zio.stream.ZStream
 import zio.test.TestResult
 import zio.test.laws._
 
+import scala.annotation.implicitNotFound
+import scala.concurrent.Future
+import scala.util.{ Success, Try }
+
 /**
  * `AssociativeFlatten` describes a type that can be "flattened" in an
  * associative way. For example, if we have a list of lists of lists, we can
diff --git a/core/shared/src/main/scala/zio/prelude/CommutativeBoth.scala b/core/shared/src/main/scala/zio/prelude/CommutativeBoth.scala
@@ -1,14 +1,14 @@
 package zio.prelude
 
-import scala.annotation.implicitNotFound
-
 import zio._
 import zio.prelude.coherent.CommutativeBothDeriveEqualInvariant
 import zio.prelude.newtypes.{ AndF, Failure, OrF }
 import zio.stream.{ ZSink, ZStream }
 import zio.test.TestResult
 import zio.test.laws._
 
+import scala.annotation.implicitNotFound
+
 /**
  * A commutative binary operator that combines two values of types `F[A]` and
  * `F[B]` to produce an `F[(A, B)]`.
diff --git a/core/shared/src/main/scala/zio/prelude/CommutativeEither.scala b/core/shared/src/main/scala/zio/prelude/CommutativeEither.scala
@@ -1,14 +1,14 @@
 package zio.prelude
 
-import scala.annotation.implicitNotFound
-import scala.concurrent.{ ExecutionContext, Future, Promise }
-
 import zio.ZIO
 import zio.prelude.coherent.CommutativeEitherDeriveEqualInvariant
 import zio.stream.{ ZSink, ZStream }
 import zio.test.TestResult
 import zio.test.laws._
 
+import scala.annotation.implicitNotFound
+import scala.concurrent.{ ExecutionContext, Future, Promise }
+
 /**
  * A commutative binary operator that combines two values of types `F[A]` and
  * `F[B]` to produce an `F[Either[A, B]]`.
diff --git a/core/shared/src/main/scala/zio/prelude/Debug.scala b/core/shared/src/main/scala/zio/prelude/Debug.scala
@@ -1,9 +1,9 @@
 package zio.prelude
 
-import scala.collection.immutable.ListMap
-
 import zio.{ Chunk, NonEmptyChunk }
 
+import scala.collection.immutable.ListMap
+
 trait Debug[-A] {
   def debug(a: A): Debug.Repr
 }
diff --git a/core/shared/src/main/scala/zio/prelude/Derive.scala b/core/shared/src/main/scala/zio/prelude/Derive.scala
@@ -1,9 +1,9 @@
 package zio.prelude
 
-import scala.util.Try
-
 import zio.{ Cause, Chunk, Exit, NonEmptyChunk }
 
+import scala.util.Try
+
 /**
  * `Derive[F, Typeclass]` represents a universally quantified function from
  * `Typeclass[A]` to `Typeclass[F[A]]` for some `F[_]`. You can think of
diff --git a/core/shared/src/main/scala/zio/prelude/Equal.scala b/core/shared/src/main/scala/zio/prelude/Equal.scala
@@ -1,15 +1,15 @@
 package zio.prelude
 
-import scala.annotation.implicitNotFound
-import scala.util.Try
-import scala.{ math => sm }
-
 import zio.Exit.{ Failure, Success }
 import zio.prelude.coherent.HashOrd
 import zio.test.TestResult
 import zio.test.laws.{ Lawful, Laws }
 import zio.{ Cause, Chunk, Exit, Fiber, NonEmptyChunk, ZTrace }
 
+import scala.annotation.implicitNotFound
+import scala.util.Try
+import scala.{ math => sm }
+
 /**
  * `Equal[A]` provides implicit evidence that two values of type `A` can be
  * compared for equality.
diff --git a/core/shared/src/main/scala/zio/prelude/GenFs.scala b/core/shared/src/main/scala/zio/prelude/GenFs.scala
@@ -1,15 +1,15 @@
 package zio.prelude
 
-import scala.concurrent.Future
-import scala.util.Try
-
 import zio.prelude.newtypes.Failure
 import zio.random.Random
 import zio.test.Gen.oneOf
 import zio.test._
 import zio.test.laws.GenF
 import zio.{ Cause, Exit, NonEmptyChunk }
 
+import scala.concurrent.Future
+import scala.util.Try
+
 /**
  * Provides higher kinded generators.
  */
diff --git a/core/shared/src/main/scala/zio/prelude/Hash.scala b/core/shared/src/main/scala/zio/prelude/Hash.scala
@@ -1,11 +1,11 @@
 package zio.prelude
 
-import scala.annotation.implicitNotFound
-
 import zio.test.TestResult
 import zio.test.laws.{ Lawful, Laws }
 import zio.{ Chunk, NonEmptyChunk }
 
+import scala.annotation.implicitNotFound
+
 /**
  * `Hash[A]` provides implicit evidence that a value of type `A` can be hashed.
  */
diff --git a/core/shared/src/main/scala/zio/prelude/IdentityBoth.scala b/core/shared/src/main/scala/zio/prelude/IdentityBoth.scala
@@ -1,12 +1,11 @@
 package zio.prelude
 
-import scala.annotation.implicitNotFound
-
+import com.github.ghik.silencer.silent
 import zio.prelude.coherent.DeriveEqualIdentityBothInvariant
 import zio.test.TestResult
 import zio.test.laws._
 
-import com.github.ghik.silencer.silent
+import scala.annotation.implicitNotFound
 
 /**
  * A binary operator that combines two values of types `F[A]` and `F[B]` to
diff --git a/core/shared/src/main/scala/zio/prelude/IdentityEither.scala b/core/shared/src/main/scala/zio/prelude/IdentityEither.scala
@@ -1,11 +1,11 @@
 package zio.prelude
 
-import scala.annotation.implicitNotFound
-
 import zio.prelude.coherent.DeriveEqualIdentityEitherInvariant
 import zio.test.TestResult
 import zio.test.laws._
 
+import scala.annotation.implicitNotFound
+
 /**
  * A binary operator that combines two values of types `F[A]` and `F[B]` to
  * produce an `F[Either[A, B]]` with an identity value.
diff --git a/core/shared/src/main/scala/zio/prelude/IdentityFlatten.scala b/core/shared/src/main/scala/zio/prelude/IdentityFlatten.scala
@@ -1,11 +1,11 @@
 package zio.prelude
 
-import scala.annotation.implicitNotFound
-
 import zio.prelude.coherent.CovariantDeriveEqualIdentityFlatten
 import zio.test.TestResult
 import zio.test.laws._
 
+import scala.annotation.implicitNotFound
+
 /**
  * `IdentityFlatten` described a type that can be "flattened" in an
  * associative way and has an identity element with respect to that operation.
diff --git a/core/shared/src/main/scala/zio/prelude/Invariant.scala b/core/shared/src/main/scala/zio/prelude/Invariant.scala
@@ -1,8 +1,5 @@
 package zio.prelude
 
-import scala.concurrent.{ ExecutionContext, Future }
-import scala.util.Try
-
 import zio.prelude.newtypes.{ Failure, FailureIn, FailureOut }
 import zio.stm.ZSTM
 import zio.stream.{ ZSink, ZStream }
@@ -22,6 +19,9 @@ import zio.{
   ZRefM
 }
 
+import scala.concurrent.{ ExecutionContext, Future }
+import scala.util.Try
+
 trait Invariant[F[_]] { self =>
 
   def invmap[A, B](f: A <=> B): F[A] <=> F[B]
diff --git a/core/shared/src/main/scala/zio/prelude/Inverse.scala b/core/shared/src/main/scala/zio/prelude/Inverse.scala
@@ -1,11 +1,11 @@
 package zio.prelude
 
-import scala.annotation.tailrec
-
 import zio.prelude.coherent.EqualInverse
 import zio.test.TestResult
 import zio.test.laws.{ Lawful, Laws }
 
+import scala.annotation.tailrec
+
 /**
  * The `Inverse` type class describes an associative binary operator for a
  * type `A` that has an identity element and an inverse binary operator.
diff --git a/core/shared/src/main/scala/zio/prelude/NonEmptyList.scala b/core/shared/src/main/scala/zio/prelude/NonEmptyList.scala
@@ -1,13 +1,13 @@
 package zio.prelude
 
-import scala.annotation.tailrec
-import scala.language.implicitConversions
-import scala.util.hashing.MurmurHash3
-
 import zio.NonEmptyChunk
 import zio.prelude.NonEmptyList._
 import zio.prelude.newtypes.{ Max, Min, Prod, Sum }
 
+import scala.annotation.tailrec
+import scala.language.implicitConversions
+import scala.util.hashing.MurmurHash3
+
 /**
  * A `NonEmptyList[A]` is a list of one or more values of type A. Unlike a
  * `List`, a `NonEmptyList` is guaranteed to contain at least one element.
diff --git a/core/shared/src/main/scala/zio/prelude/NonEmptySet.scala b/core/shared/src/main/scala/zio/prelude/NonEmptySet.scala
@@ -1,9 +1,9 @@
 package zio.prelude
 
-import scala.language.implicitConversions
-
 import zio.NonEmptyChunk
 
+import scala.language.implicitConversions
+
 final class NonEmptySet[A] private (private val set: Set[A]) { self =>
 
   /** Converts this `NonEmptySet` to a `Set`. */
diff --git a/core/shared/src/main/scala/zio/prelude/Ord.scala b/core/shared/src/main/scala/zio/prelude/Ord.scala
@@ -1,14 +1,14 @@
 package zio.prelude
 
-import scala.annotation.{ implicitNotFound, tailrec }
-import scala.{ math => sm }
-
 import zio.prelude.Equal._
 import zio.prelude.coherent.HashOrd
 import zio.test.TestResult
 import zio.test.laws.{ Lawful, Laws }
 import zio.{ Chunk, NonEmptyChunk }
 
+import scala.annotation.{ implicitNotFound, tailrec }
+import scala.{ math => sm }
+
 /**
  * `Ord[A]` provides implicit evidence that values of type `A` have a total
  * ordering.
diff --git a/core/shared/src/main/scala/zio/prelude/Validation.scala b/core/shared/src/main/scala/zio/prelude/Validation.scala
@@ -1,11 +1,11 @@
 package zio.prelude
 
-import scala.util.Try
-
 import zio.prelude.Validation._
 import zio.test.Assertion
 import zio.{ IO, ZIO }
 
+import scala.util.Try
+
 /**
  * `Validation` represents either a successful value of type `A` or a
  * collection of one or more errors of type `E`. Unlike `Either`, `Validation`
diff --git a/core/shared/src/main/scala/zio/prelude/ZNonEmptySet.scala b/core/shared/src/main/scala/zio/prelude/ZNonEmptySet.scala
diff --git a/core/shared/src/main/scala/zio/prelude/ZSet.scala b/core/shared/src/main/scala/zio/prelude/ZSet.scala
diff --git a/core/shared/src/main/scala/zio/prelude/Zivariant.scala b/core/shared/src/main/scala/zio/prelude/Zivariant.scala
diff --git a/core/shared/src/main/scala/zio/prelude/fx/ZPure.scala b/core/shared/src/main/scala/zio/prelude/fx/ZPure.scala
diff --git a/core/shared/src/main/scala/zio/prelude/package.scala b/core/shared/src/main/scala/zio/prelude/package.scala
diff --git a/core/shared/src/test/scala/zio/prelude/AssociativeSpec.scala b/core/shared/src/test/scala/zio/prelude/AssociativeSpec.scala
diff --git a/core/shared/src/test/scala/zio/prelude/DebugSpec.scala b/core/shared/src/test/scala/zio/prelude/DebugSpec.scala
diff --git a/core/shared/src/test/scala/zio/prelude/IdentitySpec.scala b/core/shared/src/test/scala/zio/prelude/IdentitySpec.scala
diff --git a/core/shared/src/test/scala/zio/prelude/fx/ZPureSpec.scala b/core/shared/src/test/scala/zio/prelude/fx/ZPureSpec.scala
diff --git a/project/plugins.sbt b/project/plugins.sbt

Original file line number	Diff line number	Diff line change
`@@ -20,11 +20,11 @@ Disable {`
`20`	`20`	`OrganizeImports {`
`21`	`21`	`expandRelative = true`
`22`	`22`	`groupedImports = Merge`
	`23`	`+ # IntelliJ IDEA's order so that they don't fight each other`
`23`	`24`	`groups = [`
`24`	`25`	`"java."`
`25`		`- "scala."`
`26`		`- "zio."`
`27`	`26`	`"*"`
	`27`	`+ "scala."`
`28`	`28`	`]`
`29`	`29`	`}`
`30`	`30`
Original file line number	Diff line number	Diff line change
`@@ -145,7 +145,7 @@ lazy val benchmarks = project.module`
`145`	`145`	`scalacOptions -= "-Xfatal-warnings",`
`146`	`146`	`libraryDependencies ++= Seq(`
`147`	`147`	`"dev.zio" %% "zio" % zioVersion,`
`148`		`- ("org.typelevel" %% "cats-core" % "2.2.0") match {`
	`148`	`+ ("org.typelevel" %% "cats-core" % "2.3.0") match {`
`149`	`149`	`case cats if isDotty.value => cats.withDottyCompat(scalaVersion.value)`
`150`	`150`	`case cats => cats`
`151`	`151`	`}`