use new Scala 3 syntax. prepare latest Scala 3

bench/src/main/scala/monocle/bench/BenchModel.scala

@@ -33,7 +33,7 @@ object BenchModel {
   case class Point3(x: Int, y: Int, z: Int)
   val p = Point3(2, 10, 24)
 
-  val map = SortedMap(1.to(200).map(_ -> 5): _*)
+  val map = SortedMap(1.to(200).map(_ -> 5) *)
 
   case class IntWrapper0(i: Int)
   case class IntWrapper1(i: Int)

docs/src/main/scala/monocle/docs/Main.scala

@@ -6,7 +6,7 @@ import scala.collection.Seq
 
 object Main {
   def sourceDirectoryPath(rest: String*): Path =
-    FileSystems.getDefault.getPath(sourceDirectory.getAbsolutePath, rest: _*)
+    FileSystems.getDefault.getPath(sourceDirectory.getAbsolutePath, rest *)
 
   def minorVersion(version: String): String = {
     val Array(major, minor, _) = version.split('.')

law/src/main/scala/monocle/law/discipline/function/AtTests.scala

@@ -13,5 +13,5 @@ object AtTests extends Laws {
     evAt: At[S, I, A],
     arbAA: Arbitrary[A => A]
   ): RuleSet =
-    new SimpleRuleSet("At", LensTests[S, A, I](at(_)).props: _*)
+    new SimpleRuleSet("At", LensTests[S, A, I](at(_)).props *)
 }

law/src/main/scala/monocle/law/discipline/function/Cons1Tests.scala

@@ -19,8 +19,8 @@ object Cons1Tests extends Laws {
   ): RuleSet =
     new SimpleRuleSet(
       "Cons1",
-      IsoTests(cons1[S, H, T]).props ++
+      (IsoTests(cons1[S, H, T]).props ++
         LensTests(head[S, H, T]).props ++
-        LensTests(tail[S, H, T]).props: _*
+        LensTests(tail[S, H, T]).props) *
     )
 }

law/src/main/scala/monocle/law/discipline/function/ConsTests.scala

@@ -19,8 +19,8 @@ object ConsTests extends Laws {
   ): RuleSet =
     new SimpleRuleSet(
       "Cons",
-      PrismTests(cons[S, A]).props ++
+      (PrismTests(cons[S, A]).props ++
         OptionalTests(headOption[S, A]).props ++
-        OptionalTests(tailOption[S, A]).props: _*
+        OptionalTests(tailOption[S, A]).props) *
     )
 }

law/src/main/scala/monocle/law/discipline/function/EachTests.scala

@@ -10,5 +10,5 @@ import cats.Eq
 
 object EachTests extends Laws {
   def apply[S: Eq: Arbitrary, A: Eq: Arbitrary](implicit evEach: Each[S, A], arbAA: Arbitrary[A => A]): RuleSet =
-    new SimpleRuleSet("Each", TraversalTests(each[S, A]).props: _*)
+    new SimpleRuleSet("Each", TraversalTests(each[S, A]).props *)
 }

law/src/main/scala/monocle/law/discipline/function/FilterIndexTests.scala

@@ -14,5 +14,5 @@ object FilterIndexTests extends Laws {
     arbAA: Arbitrary[A => A],
     arbIB: Arbitrary[I => Boolean]
   ): RuleSet =
-    new SimpleRuleSet("FilterIndex", TraversalTests(filterIndex(_: I => Boolean)(evFilterIndex)).props: _*)
+    new SimpleRuleSet("FilterIndex", TraversalTests(filterIndex(_: I => Boolean)(evFilterIndex)).props *)
 }

law/src/main/scala/monocle/law/discipline/function/IndexTests.scala

@@ -13,5 +13,5 @@ object IndexTests extends Laws {
     evIndex: Index[S, I, A],
     arbAA: Arbitrary[A => A]
   ): RuleSet =
-    new SimpleRuleSet("Index", OptionalTests(index(_: I)(evIndex)).props: _*)
+    new SimpleRuleSet("Index", OptionalTests(index(_: I)(evIndex)).props *)
 }

law/src/main/scala/monocle/law/discipline/function/PossibleTests.scala

@@ -14,5 +14,5 @@ object PossibleTests extends Laws {
     evPossible: Possible[S, A],
     arbAA: Arbitrary[A => A]
   ): RuleSet =
-    new SimpleRuleSet("Possible", OptionalTests(possible[S, A]).props: _*)
+    new SimpleRuleSet("Possible", OptionalTests(possible[S, A]).props *)
 }

law/src/main/scala/monocle/law/discipline/function/Snoc1Tests.scala

@@ -19,8 +19,8 @@ object Snoc1Tests extends Laws {
   ): RuleSet =
     new SimpleRuleSet(
       "Snoc1",
-      IsoTests(snoc1[S, I, L]).props ++
+      (IsoTests(snoc1[S, I, L]).props ++
         LensTests(init[S, I, L]).props ++
-        LensTests(last[S, I, L]).props: _*
+        LensTests(last[S, I, L]).props) *
     )
 }

law/src/main/scala/monocle/law/discipline/function/SnocTests.scala

@@ -19,8 +19,8 @@ object SnocTests extends Laws {
   ): RuleSet =
     new SimpleRuleSet(
       "Snoc",
-      PrismTests(snoc[S, A]).props ++
+      (PrismTests(snoc[S, A]).props ++
         OptionalTests(lastOption[S, A]).props ++
-        OptionalTests(initOption[S, A]).props: _*
+        OptionalTests(initOption[S, A]).props) *
     )
 }

test/shared/src/test/scala/monocle/TestInstances.scala

@@ -63,7 +63,7 @@ trait TestInstances extends PlatformSpecificTestInstances with cats.instances.Al
     Arbitrary(Arbitrary.arbitrary[List[A]].map(_.toVector))
 
   implicit def listMapArbitrary[K: Arbitrary, V: Arbitrary]: Arbitrary[ListMap[K, V]] =
-    Arbitrary(Arbitrary.arbitrary[List[(K, V)]].map(l => ListMap(l: _*)))
+    Arbitrary(Arbitrary.arbitrary[List[(K, V)]].map(l => ListMap(l *)))
 
   implicit def mapArbitrary[K: Arbitrary, V: Arbitrary]: Arbitrary[Map[K, V]] =
     Arbitrary(Arbitrary.arbitrary[List[(K, V)]].map(_.toMap))

test/shared/src/test/scala/monocle/function/Data.scala

@@ -16,7 +16,7 @@ object MSorteMap {
 
   implicit def mmapEq[K, V]: Eq[MSorteMap[K, V]] = Eq.fromUniversalEquals
   implicit def mmapArb[K: Arbitrary, V: Arbitrary](implicit ok: Order[K]): Arbitrary[MSorteMap[K, V]] =
-    Arbitrary(Arbitrary.arbitrary[List[(K, V)]].map(kvs => MSorteMap(SortedMap(kvs: _*)(ok.toOrdering))))
+    Arbitrary(Arbitrary.arbitrary[List[(K, V)]].map(kvs => MSorteMap(SortedMap(kvs *)(ok.toOrdering))))
 }
 
 case class MMap[K, V](map: Map[K, V])
@@ -27,7 +27,7 @@ object MMap {
 
   implicit def mmapEq[K, V]: Eq[MMap[K, V]] = Eq.fromUniversalEquals
   implicit def mmapArb[K: Arbitrary, V: Arbitrary]: Arbitrary[MMap[K, V]] =
-    Arbitrary(Arbitrary.arbitrary[List[(K, V)]].map(kvs => MMap(Map(kvs: _*))))
+    Arbitrary(Arbitrary.arbitrary[List[(K, V)]].map(kvs => MMap(Map(kvs *))))
 }
 
 case class CNel(head: Char, tail: List[Char])
@@ -68,7 +68,7 @@ case class Raw(b: Boolean, c: Char, i: Int, l: Long, f: Float, d: Double)
 
 object Raw extends TestInstances {
   val toTuple: Iso[Raw, (Boolean, Char, Int, Long, Float, Double)] =
-    Iso((r: Raw) => (r.b, r.c, r.i, r.l, r.f, r.d))((Raw.apply _) tupled)
+    Iso((r: Raw) => (r.b, r.c, r.i, r.l, r.f, r.d))(Raw.apply.tupled)
 
   implicit val rawEq: Eq[Raw] = Eq.fromUniversalEquals
   implicit val rawArb: Arbitrary[Raw] = Arbitrary(

test/shared/src/test/scala/monocle/function/PlatedSpec.scala

@@ -32,11 +32,11 @@ class PlatedSpec extends MonocleSuite {
     case _                     => None
   }
 
-  private val negateAll = Plated.transform(negate) _
+  private val negateAll = Plated.transform(negate)
 
-  private val addAll = Plated.rewrite(add) _
+  private val addAll = Plated.rewrite(add)
 
-  private val universe = Plated.universe[Expr] _
+  private val universe = Plated.universe[Expr]
 
   test("apply rule everywhere until that rule cannot be applied anywhere") {
     val e = Add(Add(Val(1), Val(2)), Val(3))

unsafe/src/main/scala/monocle/unsafe/MapTraversal.scala

@@ -31,7 +31,7 @@ object MapTraversal {
               .traverse { case (k, v) =>
                 (if (predicate(k)) f(v) else v.pure[F]).tupleLeft(k)
               }
-              .map(kvs => Map(kvs: _*))
+              .map(kvs => Map(kvs *))
         }
     }
 }