Update scalafmt-core to 3.8.3

.git-blame-ignore-revs

@@ -15,3 +15,6 @@ f025b0198d55d7f5c09ee976eec9e274d8dd0309
 
 # Scala Steward: Reformat with scalafmt 3.5.9
 b4d207e9fa9f1463f0827fe20101e7901fecf820
+
+# Scala Steward: Reformat with scalafmt 3.8.3
+eafb76d2b73ab736d70938196fb97de9b14c09d1

.scalafmt.conf

@@ -1,4 +1,4 @@
-version=3.8.2
+version=3.8.3
 align.openParenCallSite = true
 align.openParenDefnSite = true
 maxColumn = 120

algebra-core/src/main/scala/algebra/instances/byte.scala

@@ -40,7 +40,7 @@ class ByteAlgebra extends CommutativeRing[Byte] with Serializable {
   def one: Byte = 1
 
   def plus(x: Byte, y: Byte): Byte = (x + y).toByte
-  def negate(x: Byte): Byte = (-x).toByte
+  def negate(x: Byte): Byte = -x.toByte
   override def minus(x: Byte, y: Byte): Byte = (x - y).toByte
 
   def times(x: Byte, y: Byte): Byte = (x * y).toByte

algebra-core/src/main/scala/algebra/instances/short.scala

@@ -41,7 +41,7 @@ class ShortAlgebra extends CommutativeRing[Short] with Serializable {
   def one: Short = 1
 
   def plus(x: Short, y: Short): Short = (x + y).toShort
-  def negate(x: Short): Short = (-x).toShort
+  def negate(x: Short): Short = -x.toShort
   override def minus(x: Short, y: Short): Short = (x - y).toShort
 
   def times(x: Short, y: Short): Short = (x * y).toShort

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

@@ -50,9 +50,9 @@ sealed abstract class As[-A, +B] extends Serializable {
    */
   def substitute[F[-_]](p: F[B]): F[A]
 
-  @inline final def andThen[C](that: (B As C)): (A As C) = As.compose(that, this)
+  @inline final def andThen[C](that: B As C): A As C = As.compose(that, this)
 
-  @inline final def compose[C](that: (C As A)): (C As B) = As.compose(this, that)
+  @inline final def compose[C](that: C As A): C As B = As.compose(this, that)
 
   @inline final def coerce(a: A): B = As.witness(this)(a)
 
@@ -73,9 +73,9 @@ sealed abstract class AsInstances {
    * Subtyping forms a category
    */
   implicit val liskov: Category[As] = new Category[As] {
-    def id[A]: (A As A) = refl[A]
+    def id[A]: A As A = refl[A]
 
-    def compose[A, B, C](bc: B As C, ab: A As B): (A As C) = bc.compose(ab)
+    def compose[A, B, C](bc: B As C, ab: A As B): A As C = bc.compose(ab)
   }
 }
 
@@ -92,7 +92,7 @@ object As extends AsInstances with AsSupport {
   /**
    * Subtyping is reflexive
    */
-  implicit def refl[A]: (A As A) =
+  implicit def refl[A]: A As A =
     reflAny.asInstanceOf[A As A]
 
   /**
@@ -114,7 +114,7 @@ object As extends AsInstances with AsSupport {
   /**
    * reify a subtype relationship as a Liskov relationship
    */
-  @inline def reify[A, B >: A]: (A As B) = refl
+  @inline def reify[A, B >: A]: A As B = refl
 
   /**
    * It can be convenient to convert a <:< value into a `<~<` value.
@@ -127,7 +127,7 @@ object As extends AsInstances with AsSupport {
   /**
    * 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] = {
     type L[-α] = T[α] As T[A2]
     a.substitute[L](refl)
   }
@@ -179,7 +179,7 @@ object As extends AsInstances with AsSupport {
   def lift2[T[+_, +_], A, A2, B, B2](
     a: A As A2,
     b: B As B2
-  ): (T[A, B] As T[A2, B2]) = {
+  ): T[A, B] As T[A2, B2] = {
     type a[-X] = T[X, B2] As T[A2, B2]
     type b[-X] = T[A, X] As T[A2, B2]
     b.substitute[b](a.substitute[a](refl))
@@ -192,7 +192,7 @@ object As extends AsInstances with AsSupport {
    *  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] = {
     type L[-α] = T[B] As T[α]
     a.substitute[L](refl)
   }
@@ -201,27 +201,27 @@ object As extends AsInstances with AsSupport {
   // 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] = {
     type L[-α] = T[Z, B] As T[α, B]
     a.substitute[L](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] = {
     type L[-α] = T[A, Z] As T[A, α]
     a.substitute[L](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] = {
     type L[-α] = T[Z, B, C] As T[α, B, C]
     a.substitute[L](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] = {
     type L[-α] = T[A, Z, C] As T[A, α, C]
     a.substitute[L](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] = {
     type L[-α] = T[A, B, Z] As T[A, B, α]
     a.substitute[L](refl)
   }

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

@@ -31,7 +31,7 @@ trait ByteInstances {
 class ByteGroup extends CommutativeGroup[Byte] {
   def combine(x: Byte, y: Byte): Byte = (x + y).toByte
   def empty: Byte = 0
-  def inverse(x: Byte): Byte = (-x).toByte
+  def inverse(x: Byte): Byte = -x.toByte
   override def remove(x: Byte, y: Byte): Byte = (x - y).toByte
 }
 

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

@@ -30,7 +30,7 @@ trait ShortInstances {
 class ShortGroup extends CommutativeGroup[Short] {
   def combine(x: Short, y: Short): Short = (x + y).toShort
   def empty: Short = 0
-  def inverse(x: Short): Short = (-x).toShort
+  def inverse(x: Short): Short = -x.toShort
   override def remove(x: Short, y: Short): Short = (x - y).toShort
 }
 

tests/shared/src/test/scala/cats/tests/AsSuite.scala

@@ -103,12 +103,12 @@ class AsSuite extends CatsSuite {
   test("we can lift subtyping to covariant type constructors") {
     val cAsA: Bottom As Top = implicitly
     val co: List[Bottom] As List[Top] = As.co(cAsA)
-    val co2: ((Bottom, String) As (Top, String)) = As.co2(cAsA)
-    val co2_2: ((String, Bottom) As (String, Top)) = As.co2_2(cAsA)
-    val co3: ((Bottom, Unit, Unit) As (Top, Unit, Unit)) = As.co3(cAsA)
-    val co3_2: ((Unit, Bottom, Unit) As (Unit, Top, Unit)) = As.co3_2(cAsA)
-    val co3_3: ((Unit, Unit, Bottom) As (Unit, Unit, Top)) = As.co3_3(cAsA)
-    val lift2: ((Bottom, String) As (Top, Any)) = As.lift2(cAsA, implicitly)
+    val co2: (Bottom, String) As (Top, String) = As.co2(cAsA)
+    val co2_2: (String, Bottom) As (String, Top) = As.co2_2(cAsA)
+    val co3: (Bottom, Unit, Unit) As (Top, Unit, Unit) = As.co3(cAsA)
+    val co3_2: (Unit, Bottom, Unit) As (Unit, Top, Unit) = As.co3_2(cAsA)
+    val co3_3: (Unit, Unit, Bottom) As (Unit, Unit, Top) = As.co3_3(cAsA)
+    val lift2: (Bottom, String) As (Top, Any) = As.lift2(cAsA, implicitly)
   }
 
   test("we can lift subtyping to contravariant type constructors") {
@@ -119,7 +119,7 @@ class AsSuite extends CatsSuite {
     type EatF23[B, -A, C] = A => (B, C)
     type EatF33[B, C, -A] = A => (B, C)
 
-    val cAsA: (Bottom As Top) = implicitly
+    val cAsA: Bottom As Top = implicitly
     val contra: Eat[Top] As Eat[Bottom] = As.contra(cAsA)
     val contra1_2: EatF[Top, Unit] As EatF[Bottom, Unit] = As.contra1_2(cAsA)
     val contra2_2: Eatꟻ[Unit, Top] As Eatꟻ[Unit, Bottom] = As.contra2_2(cAsA)