Update scalafmt-core to 3.0.1

.scalafmt.conf

@@ -1,4 +1,4 @@
-version = 3.0.0
+version = 3.0.1
 
 style = defaultWithAlign
 maxColumn = 100

fetch-debug/src/main/scala/debug.scala

@@ -39,17 +39,17 @@ object debug {
   def firstRequest(r: Round): Option[Long] =
     for {
       aQuery <- r.queries.headOption
-      firstR = r.queries.foldLeft(aQuery.start)({ case (acc, q) =>
+      firstR = r.queries.foldLeft(aQuery.start) { case (acc, q) =>
         acc min q.start
-      })
+      }
     } yield firstR
 
   def lastRequest(r: Round): Option[Long] =
     for {
       aQuery <- r.queries.headOption
-      lastR = r.queries.foldLeft(aQuery.end)({ case (acc, q) =>
+      lastR = r.queries.foldLeft(aQuery.end) { case (acc, q) =>
         acc max q.end
-      })
+      }
     } yield lastR
 
   def showLog(log: Log): Document =

fetch-examples/src/test/scala/GithubExample.scala

@@ -197,9 +197,9 @@ class GithubExample extends AnyWordSpec with Matchers {
   case class Project(repo: Repo, contributors: List[Contributor], languages: List[Language])
 
   def fetchProject[F[_]: Async](repo: Repo): Fetch[F, Project] =
-    (repoContributors(repo), repoLanguages(repo)).mapN({ case (contribs, langs) =>
+    (repoContributors(repo), repoLanguages(repo)).mapN { case (contribs, langs) =>
       Project(repo = repo, contributors = contribs, languages = langs)
-    })
+    }
 
   def fetchOrg[F[_]: Async](org: String) =
     for {

fetch-examples/src/test/scala/GraphQLExample.scala

@@ -232,19 +232,19 @@ class GraphQLExample extends AnyWordSpec with Matchers {
 
 object Parsers {
   def queryParser: Parser[OrganizationQuery] =
-    rawParser.map({ case (o, n) =>
+    rawParser.map { case (o, n) =>
       OrganizationQuery(
         o,
-        n.map({ case (i, name, langs, colls) =>
+        n.map { case (i, name, langs, colls) =>
           RepositoriesQuery(
             i,
             if (name) Some(()) else None,
             if (langs) Some(LanguagesQuery()) else None,
             if (colls) Some(CollaboratorsQuery()) else None
           )
-        })
+        }
       )
-    })
+    }
 
   def rawParser: Parser[(String, Option[(Int, Boolean, Boolean, Boolean)])] =
     for {

fetch-examples/src/test/scala/JedisExample.scala

@@ -96,26 +96,26 @@ object Binary {
   ): F[ByteArray] = {
     byteOutputStream
       .mproduct(outputStream(_))
-      .use({ case (byte, out) =>
+      .use { case (byte, out) =>
         S.delay {
           out.writeObject(obj)
           out.flush()
           byte.toByteArray
         }
-      })
+      }
   }
 
   def deserialize[F[_], A](bin: ByteArray)(implicit
       S: Sync[F]
   ): F[Option[A]] = {
     byteInputStream(bin)
       .mproduct(inputStream(_))
-      .use({ case (byte, in) =>
+      .use { case (byte, in) =>
         S.delay {
           val obj = in.readObject()
           Try(obj.asInstanceOf[A]).toOption
         }
-      })
+      }
   }
 }
 
@@ -159,9 +159,9 @@ case class RedisCache[F[_]: Sync](host: String) extends DataCache[F] {
       M: Monad[F]
   ): F[DataCache[F]] =
     for {
-      bin <- vs.traverse({ case (id, v) =>
+      bin <- vs.traverse { case (id, v) =>
         Binary.serialize(v).tupleRight(cacheId(id, data))
-      })
+      }
       _ <- Sync[F].delay(bulkSet(bin))
     } yield this
 

fetch/src/main/scala/cache.scala

@@ -70,11 +70,11 @@ object InMemoryCache {
     InMemoryCache[F](Map.empty[(Data[Any, Any], DataSourceId), DataSourceResult])
 
   def from[F[_]: Monad, I, A](results: ((Data[I, A], I), A)*): InMemoryCache[F] =
-    InMemoryCache[F](results.foldLeft(Map.empty[(Data[Any, Any], DataSourceId), DataSourceResult])({
+    InMemoryCache[F](results.foldLeft(Map.empty[(Data[Any, Any], DataSourceId), DataSourceResult]) {
       case (acc, ((data, i), v)) =>
         acc.updated(
           (data.asInstanceOf[Data[Any, Any]], new DataSourceId(i)),
           new DataSourceResult(v)
         )
-    }))
+    })
 }

fetch/src/main/scala/fetch.scala

@@ -240,9 +240,9 @@ object `package` {
           .get(dsId)
           .fold(
             (ds, blocked)
-          )({ case (d, req) =>
+          ) { case (d, req) =>
             (d, combineRequests(blocked, req))
-          })
+          }
         acc.updated(dsId, combined)
       }
     )
@@ -601,9 +601,9 @@ object `package` {
           requests <- FetchExecution.parallel(
             NonEmptyList
               .fromListUnsafe(blocked)
-              .map({ case (ds, req) =>
+              .map { case (ds, req) =>
                 runBlockedRequest(req, ds, cache, log)
-              })
+              }
           )
           performedRequests = requests.foldLeft(List.empty[Request])(_ ++ _)
           _ <-

fetch/src/test/scala/FetchBatchingTests.scala

@@ -109,12 +109,12 @@ class FetchBatchingTests extends FetchSpec {
 
     val io = Fetch.runLog[IO](fetch)
 
-    io.map({ case (log, result) =>
+    io.map { case (log, result) =>
       result shouldEqual List(1, 2, 3, 4, 5)
       log.rounds.size shouldEqual 1
       totalFetched(log.rounds) shouldEqual 5
       totalBatches(log.rounds) shouldEqual 3
-    }).unsafeToFuture()
+    }.unsafeToFuture()
   }
 
   "A large fetch to a datasource with a maximum batch size is split and executed in parallel" in {
@@ -123,12 +123,12 @@ class FetchBatchingTests extends FetchSpec {
 
     val io = Fetch.runLog[IO](fetch)
 
-    io.map({ case (log, result) =>
+    io.map { case (log, result) =>
       result shouldEqual List(1, 2, 3, 4, 5)
       log.rounds.size shouldEqual 1
       totalFetched(log.rounds) shouldEqual 5
       totalBatches(log.rounds) shouldEqual 3
-    }).unsafeToFuture()
+    }.unsafeToFuture()
   }
 
   "Fetches to datasources with a maximum batch size should be split and executed in parallel and sequentially when using productR" in {
@@ -138,12 +138,12 @@ class FetchBatchingTests extends FetchSpec {
 
     val io = Fetch.runLog[IO](fetch)
 
-    io.map({ case (log, result) =>
+    io.map { case (log, result) =>
       result shouldEqual List(1, 2, 3, 4, 5)
       log.rounds.size shouldEqual 1
       totalFetched(log.rounds) shouldEqual 5 + 5
       totalBatches(log.rounds) shouldEqual 3 + 3
-    }).unsafeToFuture()
+    }.unsafeToFuture()
   }
 
   "Fetches to datasources with a maximum batch size should be split and executed in parallel and sequentially when using productL" in {
@@ -153,12 +153,12 @@ class FetchBatchingTests extends FetchSpec {
 
     val io = Fetch.runLog[IO](fetch)
 
-    io.map({ case (log, result) =>
+    io.map { case (log, result) =>
       result shouldEqual List(1, 2, 3, 4, 5)
       log.rounds.size shouldEqual 1
       totalFetched(log.rounds) shouldEqual 5 + 5
       totalBatches(log.rounds) shouldEqual 3 + 3
-    }).unsafeToFuture()
+    }.unsafeToFuture()
   }
 
   "A large (many) fetch to a datasource with a maximum batch size is split and executed in sequence" in {
@@ -167,12 +167,12 @@ class FetchBatchingTests extends FetchSpec {
 
     val io = Fetch.runLog[IO](fetch)
 
-    io.map({ case (log, result) =>
+    io.map { case (log, result) =>
       result shouldEqual List(1, 2, 3)
       log.rounds.size shouldEqual 1
       totalFetched(log.rounds) shouldEqual 3
       totalBatches(log.rounds) shouldEqual 2
-    }).unsafeToFuture()
+    }.unsafeToFuture()
   }
 
   "A large (many) fetch to a datasource with a maximum batch size is split and executed in parallel" in {
@@ -181,12 +181,12 @@ class FetchBatchingTests extends FetchSpec {
 
     val io = Fetch.runLog[IO](fetch)
 
-    io.map({ case (log, result) =>
+    io.map { case (log, result) =>
       result shouldEqual List(1, 2, 3)
       log.rounds.size shouldEqual 1
       totalFetched(log.rounds) shouldEqual 3
       totalBatches(log.rounds) shouldEqual 2
-    }).unsafeToFuture()
+    }.unsafeToFuture()
   }
 
   "Very deep fetches don't overflow stack or heap" in {
@@ -203,8 +203,8 @@ class FetchBatchingTests extends FetchSpec {
       ids.toList.traverse(fetchBatchedDataBigId[IO])
     )
 
-    io.map({ case (log, result) =>
+    io.map { case (log, result) =>
       result shouldEqual ids.map(_.toString)
-    }).unsafeToFuture()
+    }.unsafeToFuture()
   }
 }

fetch/src/test/scala/FetchReportingTests.scala

@@ -29,9 +29,9 @@ class FetchReportingTests extends FetchSpec {
 
     val io = Fetch.runLog[IO](fetch)
 
-    io.map({ case (log, result) =>
+    io.map { case (log, result) =>
       log.rounds.size shouldEqual 0
-    }).unsafeToFuture()
+    }.unsafeToFuture()
   }
 
   "Single fetches are executed in one round" in {
@@ -40,9 +40,9 @@ class FetchReportingTests extends FetchSpec {
 
     val io = Fetch.runLog[IO](fetch[IO])
 
-    io.map({ case (log, result) =>
+    io.map { case (log, result) =>
       log.rounds.size shouldEqual 1
-    }).unsafeToFuture()
+    }.unsafeToFuture()
   }
 
   "Single fetches are executed in one round per binding in a for comprehension" in {
@@ -54,9 +54,9 @@ class FetchReportingTests extends FetchSpec {
 
     val io = Fetch.runLog[IO](fetch)
 
-    io.map({ case (log, result) =>
+    io.map { case (log, result) =>
       log.rounds.size shouldEqual 2
-    }).unsafeToFuture()
+    }.unsafeToFuture()
   }
 
   "Single fetches for different data sources are executed in multiple rounds if they are in a for comprehension" in {
@@ -68,9 +68,9 @@ class FetchReportingTests extends FetchSpec {
 
     val io = Fetch.runLog[IO](fetch)
 
-    io.map({ case (log, result) =>
+    io.map { case (log, result) =>
       log.rounds.size shouldEqual 2
-    }).unsafeToFuture()
+    }.unsafeToFuture()
   }
 
   "Single fetches combined with cartesian are run in one round" in {
@@ -79,9 +79,9 @@ class FetchReportingTests extends FetchSpec {
 
     val io = Fetch.runLog[IO](fetch)
 
-    io.map({ case (log, result) =>
+    io.map { case (log, result) =>
       log.rounds.size shouldEqual 1
-    }).unsafeToFuture()
+    }.unsafeToFuture()
   }
 
   "Single fetches combined with traverse are run in one round" in {
@@ -93,9 +93,9 @@ class FetchReportingTests extends FetchSpec {
 
     val io = Fetch.runLog[IO](fetch)
 
-    io.map({ case (log, result) =>
+    io.map { case (log, result) =>
       log.rounds.size shouldEqual 2
-    }).unsafeToFuture()
+    }.unsafeToFuture()
   }
 
   "The product of two fetches from the same data source implies batching" in {
@@ -104,9 +104,9 @@ class FetchReportingTests extends FetchSpec {
 
     val io = Fetch.runLog[IO](fetch)
 
-    io.map({ case (log, result) =>
+    io.map { case (log, result) =>
       log.rounds.size shouldEqual 1
-    }).unsafeToFuture()
+    }.unsafeToFuture()
   }
 
   "The product of concurrent fetches of the same type implies everything fetched in batches" in {
@@ -129,10 +129,10 @@ class FetchReportingTests extends FetchSpec {
 
     val io = Fetch.runLog[IO](fetch)
 
-    io.map({ case (log, result) =>
+    io.map { case (log, result) =>
       log.rounds.size shouldEqual 2
       totalBatches(log.rounds) shouldEqual 1
       totalFetched(log.rounds) shouldEqual 3 + 1
-    }).unsafeToFuture()
+    }.unsafeToFuture()
   }
 }