scala tweaks while reviewing swiss scoring

Author: ornicar

modules/swiss/src/main/SwissScoring.scala

@@ -24,39 +24,34 @@ final private class SwissScoring(mongo: SwissMongo)(using
   private def recompute(id: SwissId): Fu[Option[SwissScoring.Result]] =
     mongo.swiss.byId[Swiss](id) flatMap {
       _.so { swiss =>
-        for {
+        for
           (prevPlayers, pairings) <- fetchPlayers(swiss) zip fetchPairings(swiss)
           pairingMap = SwissPairing.toMap(pairings)
           sheets     = SwissSheet.many(swiss, prevPlayers, pairingMap)
-          withPoints = (prevPlayers zip sheets).map { case (player, sheet) =>
+          withPoints = (prevPlayers zip sheets).map: (player, sheet) =>
             player.copy(points = sheet.points)
-          }
           playerMap = withPoints.mapBy(_.userId)
-          players = withPoints.map { p =>
+          players = withPoints.map: p =>
             val playerPairings = (~pairingMap.get(p.userId)).values
-            val (tieBreak, perfSum) = playerPairings.foldLeft(0f -> 0f) {
+            val (tieBreak, perfSum) = playerPairings.foldLeft(0f -> 0f):
               case ((tieBreak, perfSum), pairing) =>
                 val opponent       = playerMap.get(pairing opponentOf p.userId)
                 val opponentPoints = opponent.so(_.points.value)
                 val result         = pairing.resultFor(p.userId)
                 val newTieBreak    = tieBreak + result.fold(opponentPoints / 2) { _ so opponentPoints }
-                val newPerf = perfSum + opponent.so(_.rating.value) + result.so { win =>
-                  if (win) 500 else -500
-                }
+                val newPerf = perfSum + opponent.so(_.rating.value) + result.so: win =>
+                  if win then 500 else -500
                 newTieBreak -> newPerf
-            }
             p.copy(
               tieBreak = Swiss.TieBreak(tieBreak),
               performance = playerPairings.nonEmpty option Swiss.Performance(perfSum / playerPairings.size)
             ).recomputeScore
-          }
-          _ <- SwissPlayer.fields { f =>
+          _ <- SwissPlayer.fields: f =>
             prevPlayers
               .zip(players)
-              .withFilter { case (a, b) =>
+              .withFilter: (a, b) =>
                 a != b
-              }
-              .map { case (_, player) =>
+              .map: (_, player) =>
                 mongo.player.update
                   .one(
                     $id(player.id),
@@ -68,11 +63,9 @@ final private class SwissScoring(mongo: SwissMongo)(using
                     )
                   )
                   .void
-              }
               .parallel
               .void
-          }
-        } yield SwissScoring
+        yield SwissScoring
           .Result(
             swiss,
             players.zip(sheets).sortBy(-_._1.score.value),

modules/swiss/src/main/SwissSheet.scala

@@ -41,17 +41,16 @@ private object SwissSheet:
       players: List[SwissPlayer],
       pairingMap: SwissPairing.PairingMap
   ): List[SwissSheet] =
-    players.map { player =>
+    players.map: player =>
       one(swiss, ~pairingMap.get(player.userId), player)
-    }
 
   def one(
       swiss: Swiss,
       pairingMap: Map[SwissRoundNumber, SwissPairing],
       player: SwissPlayer
   ): SwissSheet =
-    SwissSheet {
-      swiss.allRounds.map { round =>
+    SwissSheet:
+      swiss.allRounds.map: round =>
         pairingMap get round match
           case Some(pairing) =>
             pairing.status match
@@ -63,8 +62,6 @@ private object SwissSheet:
           case None if player.byes(round) => Bye
           case None if round.value == 1   => Late
           case None                       => Absent
-      }
-    }
 
 final private class SwissSheetApi(mongo: SwissMongo)(using
     Executor,
@@ -76,24 +73,22 @@ final private class SwissSheetApi(mongo: SwissMongo)(using
       sort: Bdoc
   ): Source[(SwissPlayer, Map[SwissRoundNumber, SwissPairing], SwissSheet), ?] =
     val readPreference =
-      if (swiss.finishedAt.exists(_ isBefore nowInstant.minusSeconds(10)))
-        temporarilyPrimary
+      if swiss.finishedAt.exists(_ isBefore nowInstant.minusSeconds(10))
+      then temporarilyPrimary
       else ReadPreference.primary
     SwissPlayer
-      .fields { f =>
+      .fields: f =>
         mongo.player.find($doc(f.swissId -> swiss.id)).sort(sort)
-      }
       .cursor[SwissPlayer](readPreference)
       .documentSource()
-      .mapAsync(4) { player =>
-        SwissPairing.fields { f =>
-          mongo.pairing.list[SwissPairing](
-            $doc(f.swissId -> swiss.id, f.players -> player.userId),
-            readPreference
-          ) dmap { player -> _ }
-        }
-      }
-      .map { (player, pairings) =>
+      .mapAsync(4): player =>
+        SwissPairing.fields: f =>
+          mongo.pairing
+            .list[SwissPairing](
+              $doc(f.swissId -> swiss.id, f.players -> player.userId),
+              readPreference
+            )
+            .dmap(player -> _)
+      .map: (player, pairings) =>
         val pairingMap = pairings.mapBy(_.round)
         (player, pairingMap, SwissSheet.one(swiss, pairingMap, player))
-      }