Scala tweak

src/main/scala/Speed.scala

@@ -69,4 +69,4 @@ object Speed:
 
   def apply(clock: Option[Clock.Config]) = byTime(clock.fold(Int.MaxValue)(_.estimateTotalSeconds))
 
-  def byTime(seconds: Int): Speed = all.find(_.range contains seconds) | Correspondence
+  def byTime(seconds: Int): Speed = all.find(_.range.contains(seconds)) | Correspondence

src/main/scala/format/Uci.scala

@@ -83,15 +83,15 @@ object Uci:
   def apply(drop: chess.Drop) = Uci.Drop(drop.piece.role, drop.square)
 
   def apply(move: String): Option[Uci] =
-    if move.lift(1) contains '@' then
+    if move.lift(1).contains('@') then
       for
         role   <- move.headOption.flatMap(Role.allByPgn.get)
         square <- Square.fromKey(move.slice(2, 4))
       yield Uci.Drop(role, square)
     else Uci.Move(move)
 
   def fromChars(move: String): Option[Uci] =
-    if move.lift(1) contains '@' then Uci.Drop.fromChars(move)
+    if move.lift(1).contains('@') then Uci.Drop.fromChars(move)
     else Uci.Move.fromChars(move)
 
   def readList(moves: String): Option[List[Uci]] =

src/main/scala/format/pgn/Glyph.scala

@@ -21,7 +21,7 @@ case class Glyphs(
       case g: Glyph.PositionAssessment => copy(position = (!position.contains(g)).option(g))
       case g: Glyph.Observation =>
         copy(observations =
-          if observations contains g then observations.filter(g !=)
+          if observations.contains(g) then observations.filter(g !=)
           else g :: observations
         )
       case _ => this

src/main/scala/opening/OpeningDb.scala

@@ -16,13 +16,13 @@ object OpeningDb:
 
   // Keep only one opening per unique key: the shortest one
   lazy val shortestLines: Map[OpeningKey, Opening] = OpeningDb.all
-    .foldLeft(Map.empty[OpeningKey, Opening]) { case (acc, op) =>
+    .foldLeft(Map.empty) { case (acc, op) =>
       acc.updatedWith(op.key):
         case Some(prev) if prev.uci.value.size < op.uci.value.size => prev.some
         case _                                                     => op.some
     }
 
-  def isShortest(op: Opening) = shortestLines.get(op.key) contains op
+  def isShortest(op: Opening) = shortestLines.get(op.key).contains(op)
 
   def findByEpdFen(fen: EpdFen): Option[Opening] = findByStandardFen(fen.opening)
 

src/main/scala/variant/Variant.scala

@@ -219,10 +219,10 @@ object Variant:
   def byName(name: String): Option[Variant] =
     list.all.find(_.name.toLowerCase == name.toLowerCase)
 
-  def exists(id: Id): Boolean = list.byId contains id
+  def exists(id: Id): Boolean = list.byId.contains(id)
 
   private[variant] def symmetricRank(rank: IndexedSeq[Role]): Map[Square, Piece] =
-    File.all.zip(rank).map { (x, role) => Square(x, Rank.First) -> (White - role) } ++
-      File.all.map { Square(_, Rank.Second) -> White.pawn } ++
-      File.all.map { Square(_, Rank.Seventh) -> Black.pawn } ++
-      File.all.zip(rank).map { (x, role) => Square(x, Rank.Eighth) -> (Black - role) } toMap
+    File.all.zip(rank).map((x, role) => Square(x, Rank.First) -> (White - role)) ++
+      File.all.map(Square(_, Rank.Second) -> White.pawn) ++
+      File.all.map(Square(_, Rank.Seventh) -> Black.pawn) ++
+      File.all.zip(rank).map((x, role) => Square(x, Rank.Eighth) -> (Black - role)) toMap