Merge pull request #2908 from fthomas/update/sbt-scalafmt-2.0.1

Update sbt-scalafmt to 2.0.1

.scalafmt.conf

@@ -1,3 +1,6 @@
+version=2.0.0-RC8
+align.openParenCallSite = true
+align.openParenDefnSite = true
 maxColumn = 120
 continuationIndent.defnSite = 2
 assumeStandardLibraryStripMargin = true

build.sbt

@@ -98,7 +98,7 @@ lazy val catsSettings = Seq(
   libraryDependencies ++= Seq(
     "org.typelevel" %%% "machinist" % "0.6.8",
     compilerPlugin("org.typelevel" %% "kind-projector" % kindProjectorVersion)
-  ) ++ macroDependencies(scalaVersion.value),
+  ) ++ macroDependencies(scalaVersion.value)
 ) ++ commonSettings ++ publishSettings ++ scoverageSettings ++ simulacrumSettings
 
 lazy val simulacrumSettings = Seq(
@@ -304,7 +304,7 @@ def mimaSettings(moduleName: String) =
         exclude[DirectMissingMethodProblem]("cats.data.KleisliInstances4.catsDataCommutativeFlatMapForKleisli"),
         exclude[DirectMissingMethodProblem]("cats.data.IRWSTInstances1.catsDataStrongForIRWST"),
         exclude[DirectMissingMethodProblem]("cats.data.OptionTInstances1.catsDataMonadErrorMonadForOptionT"),
-        exclude[DirectMissingMethodProblem]("cats.data.OptionTInstances1.catsDataMonadErrorForOptionT"),
+        exclude[DirectMissingMethodProblem]("cats.data.OptionTInstances1.catsDataMonadErrorForOptionT")
       ) ++
         //These things are Ops classes that shouldn't have the `value` exposed. These should have never been public because they don't
         //provide any value. Making them private because of issues like #2514 and #2613.

core/src/main/scala/cats/Eval.scala

@@ -84,7 +84,7 @@ sealed abstract class Eval[+A] extends Serializable { self =>
               type Start = A
               val start = () => c.run(s)
               val run = f
-          }
+            }
         }
       case c: Eval.Defer[A] =>
         new Eval.FlatMap[B] {

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

@@ -502,7 +502,7 @@ import Foldable.sentinel
         f(a) match {
           case Right(c) => (A.empty[B], A.pure(c))
           case Left(b)  => (A.pure(b), A.empty[C])
-      }
+        }
     )
   }
 

core/src/main/scala/cats/Monad.scala

@@ -33,7 +33,7 @@ import simulacrum.typeclass
             }
           },
           ifFalse = pure(Right(xs))
-      )
+        )
     )
   }
 
@@ -53,7 +53,7 @@ import simulacrum.typeclass
             map(b.value)(_ => continue)
           },
           ifFalse = stop
-      )
+        )
     )
   }
 

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

@@ -199,7 +199,7 @@ import simulacrum.typeclass
             case (Right(c), _)           => ior.map(c :: _)
             case (Left(b), Ior.Right(r)) => Ior.bothNel(b, r)
             case (Left(b), _)            => ior.leftMap(b :: _)
-        }
+          }
       )
 
     reduceRightTo(fa)(a => f(a).bimap(NonEmptyList.one, NonEmptyList.one).toIor)(g).value

core/src/main/scala/cats/data/Chain.scala

@@ -421,7 +421,9 @@ sealed abstract class Chain[+A] {
     var first = true
 
     foreach { a =>
-      if (first) { builder ++= AA.show(a); first = false } else builder ++= ", " + AA.show(a)
+      if (first) {
+        builder ++= AA.show(a); first = false
+      } else builder ++= ", " + AA.show(a)
       ()
     }
     builder += ')'

core/src/main/scala/cats/data/EitherT.scala

@@ -646,7 +646,7 @@ private[data] trait EitherTMonad[F[_], L] extends Monad[EitherT[F, L, ?]] with E
             case Left(l)         => Right(Left(l))
             case Right(Left(a1)) => Left(a1)
             case Right(Right(b)) => Right(Right(b))
-        }
+          }
       )
     )
 }

core/src/main/scala/cats/data/IndexedStateT.scala

@@ -144,12 +144,13 @@ final class IndexedStateT[F[_], SA, SB, A](val runF: F[SA => F[(SB, A)]]) extend
    * }}}
    */
   def transformS[R](f: R => SA, g: (R, SB) => R)(implicit F: Functor[F]): IndexedStateT[F, R, R, A] =
-    StateT.applyF(F.map(runF) { sfsa =>
-      { r: R =>
-        val sa = f(r)
-        val fsba = sfsa(sa)
-        F.map(fsba) { case (sb, a) => (g(r, sb), a) }
-      }
+    StateT.applyF(F.map(runF) {
+      sfsa =>
+        { r: R =>
+          val sa = f(r)
+          val fsba = sfsa(sa)
+          F.map(fsba) { case (sb, a) => (g(r, sb), a) }
+        }
     })
 
   /**
@@ -438,7 +439,7 @@ sealed abstract private[data] class IndexedStateTMonad[F[_], S]
       s =>
         F.tailRecM[(S, A), (S, B)]((s, a)) {
           case (s, a) => F.map(f(a).run(s)) { case (s, ab) => ab.bimap((s, _), (s, _)) }
-      }
+        }
     )
 }
 
@@ -475,7 +476,7 @@ sealed abstract private[data] class IndexedStateTContravariantMonoidal[F[_], S]
             (tup: (S, A)) =>
               f(tup._2) match {
                 case (b, c) => (G.pure((tup._1, b)), G.pure((tup._1, c)))
-            }
+              }
           )(G, F)
       )
     )

core/src/main/scala/cats/data/Kleisli.scala

@@ -481,7 +481,7 @@ private[data] trait KleisliArrowChoice[F[_]]
         fe match {
           case Left(a)  => F.map(f(a))(Left.apply _)
           case Right(b) => F.map(g(b))(Right.apply _)
-      }
+        }
     )
 }
 

core/src/main/scala/cats/data/NonEmptyList.scala

@@ -258,7 +258,10 @@ final case class NonEmptyList[+A](head: A, tail: List[A]) {
 
     val buf = ListBuffer.empty[AA]
     tail.foldLeft(TreeSet(head: AA)) { (elementsSoFar, b) =>
-      if (elementsSoFar(b)) elementsSoFar else { buf += b; elementsSoFar + b }
+      if (elementsSoFar(b)) elementsSoFar
+      else {
+        buf += b; elementsSoFar + b
+      }
     }
 
     NonEmptyList(head, buf.toList)
@@ -592,7 +595,7 @@ sealed abstract private[data] class NonEmptyListInstances extends NonEmptyListIn
               case (Right(c), _)           => ior.map(c :: _)
               case (Left(b), Ior.Right(r)) => Ior.bothNel(b, r)
               case (Left(b), _)            => ior.leftMap(b :: _)
-          }
+            }
         )
 
       }

core/src/main/scala/cats/data/NonEmptyVector.scala

@@ -197,7 +197,10 @@ final class NonEmptyVector[+A] private (val toVector: Vector[A]) extends AnyVal
 
     val buf = Vector.newBuilder[AA]
     tail.foldLeft(TreeSet(head: AA)) { (elementsSoFar, a) =>
-      if (elementsSoFar(a)) elementsSoFar else { buf += a; elementsSoFar + a }
+      if (elementsSoFar(a)) elementsSoFar
+      else {
+        buf += a; elementsSoFar + a
+      }
     }
 
     NonEmptyVector(head, buf.result())
@@ -315,7 +318,7 @@ sealed abstract private[data] class NonEmptyVectorInstances {
               case (Right(c), _)           => ior.map(_ :+ c)
               case (Left(b), Ior.Right(_)) => ior.putLeft(NonEmptyVector.one(b))
               case (Left(b), _)            => ior.leftMap(_ :+ b)
-          }
+            }
         ).bimap(_.toNonEmptyList, _.toNonEmptyList)
 
       }

core/src/main/scala/cats/data/OptionT.scala

@@ -363,7 +363,7 @@ private[data] trait OptionTMonad[F[_]] extends Monad[OptionT[F, ?]] {
         a0 =>
           F.map(f(a0).value)(
             _.fold(Either.right[A, Option[B]](None))(_.map(b => Some(b): Option[B]))
-        )
+          )
       )
     )
 }
@@ -405,7 +405,7 @@ private trait OptionTContravariantMonoidal[F[_]] extends ContravariantMonoidal[O
           t match {
             case Some((x, y)) => (Some(x), Some(y))
             case None         => (None, None)
-        }
+          }
       )
     )
 }

core/src/main/scala/cats/data/WriterT.scala

@@ -479,7 +479,7 @@ sealed private[data] trait WriterTContravariantMonoidal[F[_], L] extends Contrav
         (t: (L, (A, B))) =>
           t match {
             case (l, (a, b)) => ((l, a), (l, b))
-        }
+          }
       )
     )
 }

core/src/main/scala/cats/evidence/As.scala

@@ -27,7 +27,7 @@ sealed abstract class As[-A, +B] extends Serializable {
    * to a function, such as F in: `type F[-B] = B => String`. In this
    * case, we could use A As B to turn an F[B] Into F[A].
    */
-  def substitute[F[- _]](p: F[B]): F[A]
+  def substitute[F[-_]](p: F[B]): F[A]
 
   @inline final def andThen[C](that: (B As C)): (A As C) = As.compose(that, this)
 
@@ -56,7 +56,7 @@ object As extends AsInstances {
    * single value.
    */
   private[this] val reflAny = new (Any As Any) {
-    def substitute[F[- _]](fa: F[Any]) = fa
+    def substitute[F[-_]](fa: F[Any]) = fa
   }
 
   /**
@@ -94,30 +94,30 @@ object As extends AsInstances {
   /**
    * We can lift subtyping into any covariant type constructor
    */
-  def co[T[+ _], A, A2](a: A As A2): (T[A] As T[A2]) =
+  def co[T[+_], A, A2](a: A As A2): (T[A] As T[A2]) =
     a.substitute[λ[`-α` => T[α] As T[A2]]](refl)
 
   // Similarly, we can do this any time we find a covariant type
   // parameter. Here we provide the proof for what we expect to be the
   // most common shapes.
 
-  def co2[T[+ _, _], Z, A, B](a: A As Z): T[A, B] As T[Z, B] =
+  def co2[T[+_, _], Z, A, B](a: A As Z): T[A, B] As T[Z, B] =
     a.substitute[λ[`-α` => T[α, B] As T[Z, B]]](refl)
 
   /**
    * Widen a F[X,+A] to a F[X,B] if (A As B). This can be used to widen
    * the output of a Function1, for example.
    */
-  def co2_2[T[_, + _], Z, A, B](a: B As Z): T[A, B] As T[A, Z] =
+  def co2_2[T[_, +_], Z, A, B](a: B As Z): T[A, B] As T[A, Z] =
     a.substitute[λ[`-α` => T[A, α] As T[A, Z]]](refl)
 
-  def co3[T[+ _, _, _], Z, A, B, C](a: A As Z): T[A, B, C] As T[Z, B, C] =
+  def co3[T[+_, _, _], Z, A, B, C](a: A As Z): T[A, B, C] As T[Z, B, C] =
     a.substitute[λ[`-α` => T[α, B, C] As T[Z, B, C]]](refl)
 
-  def co3_2[T[_, + _, _], Z, A, B, C](a: B As Z): T[A, B, C] As T[A, Z, C] =
+  def co3_2[T[_, +_, _], Z, A, B, C](a: B As Z): T[A, B, C] As T[A, Z, C] =
     a.substitute[λ[`-α` => T[A, α, C] As T[A, Z, C]]](refl)
 
-  def co3_3[T[+ _, _, + _], Z, A, B, C](a: C As Z): T[A, B, C] As T[A, B, Z] =
+  def co3_3[T[+_, _, +_], Z, A, B, C](a: C As Z): T[A, B, C] As T[A, B, Z] =
     a.substitute[λ[`-α` => T[A, B, α] As T[A, B, Z]]](refl)
 
   /**
@@ -131,7 +131,7 @@ object As extends AsInstances {
    *
    * lift2(a,b) = co1_2(a) compose co2_2(b)
    */
-  def lift2[T[+ _, + _], A, A2, B, B2](
+  def lift2[T[+_, +_], A, A2, B, B2](
     a: A As A2,
     b: B As B2
   ): (T[A, B] As T[A2, B2]) = {
@@ -147,26 +147,26 @@ object As extends AsInstances {
    *  Given that F has the shape: F[-_], we show that:
    *     (A As B) implies (F[B] As F[A])
    */
-  def contra[T[- _], A, B](a: A As B): (T[B] As T[A]) =
+  def contra[T[-_], A, B](a: A As B): (T[B] As T[A]) =
     a.substitute[λ[`-α` => T[B] As T[α]]](refl)
 
   // Similarly, we can do this any time we find a contravariant type
   // parameter. Here we provide the proof for what we expect to be the
   // most common shapes.
 
-  def contra1_2[T[- _, _], Z, A, B](a: A As Z): (T[Z, B] As T[A, B]) =
+  def contra1_2[T[-_, _], Z, A, B](a: A As Z): (T[Z, B] As T[A, B]) =
     a.substitute[λ[`-α` => T[Z, B] As T[α, B]]](refl)
 
-  def contra2_2[T[_, - _], Z, A, B](a: B As Z): (T[A, Z] As T[A, B]) =
+  def contra2_2[T[_, -_], Z, A, B](a: B As Z): (T[A, Z] As T[A, B]) =
     a.substitute[λ[`-α` => T[A, Z] As T[A, α]]](refl)
 
-  def contra1_3[T[- _, _, _], Z, A, B, C](a: A As Z): (T[Z, B, C] As T[A, B, C]) =
+  def contra1_3[T[-_, _, _], Z, A, B, C](a: A As Z): (T[Z, B, C] As T[A, B, C]) =
     a.substitute[λ[`-α` => T[Z, B, C] As T[α, B, C]]](refl)
 
-  def contra2_3[T[_, - _, _], Z, A, B, C](a: B As Z): (T[A, Z, C] As T[A, B, C]) =
+  def contra2_3[T[_, -_, _], Z, A, B, C](a: B As Z): (T[A, Z, C] As T[A, B, C]) =
     a.substitute[λ[`-α` => T[A, Z, C] As T[A, α, C]]](refl)
 
-  def contra3_3[T[_, _, - _], Z, A, B, C](a: C As Z): (T[A, B, Z] As T[A, B, C]) =
+  def contra3_3[T[_, _, -_], Z, A, B, C](a: C As Z): (T[A, B, Z] As T[A, B, C]) =
     a.substitute[λ[`-α` => T[A, B, Z] As T[A, B, α]]](refl)
 
   /**

core/src/main/scala/cats/instances/function.scala

@@ -107,7 +107,7 @@ sealed private[instances] trait Function1Instances extends Function1Instances0 {
         (ab: (A, B)) =>
           ab match {
             case (a, b) => Monoid[R].combine(fa(a), fb(b))
-        }
+          }
     }
 
   implicit def catsStdMonadForFunction1[T1]: Monad[T1 => ?] =

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

@@ -88,7 +88,7 @@ trait ListInstances extends cats.kernel.instances.ListInstances {
             f(a) match {
               case Left(b)  => (b :: acc._1, acc._2)
               case Right(c) => (acc._1, c :: acc._2)
-          }
+            }
         )
 
       @tailrec

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

@@ -200,7 +200,7 @@ final class FoldableOps[F[_], A](private val fa: F[A]) extends AnyVal {
         f(a) match {
           case Some(x) => M.combine(acc, x)
           case None    => acc
-      }
+        }
     )
 }
 
@@ -356,7 +356,7 @@ final class FoldableOps1[F[_]](private val F: Foldable[F]) extends AnyVal {
       a =>
         M.map(f(a)) {
           H.bifoldMap[B, C, (F[B], F[C])](_)(b => (A.pure(b), A.empty[C]), c => (A.empty[B], A.pure(c)))
-      }
+        }
     )
   }
 

free/src/test/scala/cats/free/CofreeSuite.scala

@@ -72,7 +72,7 @@ class CofreeSuite extends CatsSuite {
           } else {
             spooky.increment()
             Some(spooky.counter)
-        }
+          }
       )
     spooky.counter should ===(0)
     incrementor.forceAll
@@ -163,7 +163,7 @@ sealed trait CofreeSuiteInstances {
           (l.head, l.tail) match {
             case (h, Nil) => nelToCofNel(NonEmptyList(h, Nil))
             case (h, t)   => nelToCofNel(NonEmptyList(h, t))
-        }
+          }
       )
     }
   }

kernel/src/main/scala/cats/kernel/instances/DoubleInstances.scala

@@ -8,7 +8,7 @@ trait DoubleInstances {
 
 class DoubleGroup extends CommutativeGroup[Double] {
   def combine(x: Double, y: Double): Double = x + y
-  def empty: Double = 0D
+  def empty: Double = 0d
   def inverse(x: Double): Double = -x
   override def remove(x: Double, y: Double): Double = x - y
 }

kernel/src/main/scala/cats/kernel/instances/FloatInstances.scala

@@ -11,7 +11,7 @@ trait FloatInstances {
  */
 class FloatGroup extends CommutativeGroup[Float] {
   def combine(x: Float, y: Float): Float = x + y
-  def empty: Float = 0F
+  def empty: Float = 0f
   def inverse(x: Float): Float = -x
   override def remove(x: Float, y: Float): Float = x - y
 }