fix compilation and align types for wartremover ⚡

Author: mcanlas

benchmark/src/main/scala/com/htmlism/spawningpool/Benchmark.scala

@@ -6,26 +6,25 @@ object Benchmark {
       println()
       println(s"Running $n...")
 
-      val start = compat.Platform.currentTime
+      val start = System.currentTimeMillis()
 
       f()
 
-      val duration         = compat.Platform.currentTime - start
+      val duration         = System.currentTimeMillis() - start
       val duratinInSeconds = duration / 1000
 
       duratinInSeconds
     }
 
   def apply[A](fs: Map[A, () => Unit], times: Int): Unit = {
     val durations = fs
-      .mapValues(toDurations(times))
-      .map(identity)
+      .map { case (k, v) => (k, toDurations(times)(v)) }
 
     println("Durations:")
     durations.foreach(println)
 
     val averages = durations
-      .mapValues(_.sum / times)
+      .map { case (k, v) => (k, v.sum / times) }
 
     println("Average duration:")
     averages.foreach(println)

benchmark/src/main/scala/com/htmlism/spawningpool/VectorVsArray.scala

@@ -22,8 +22,9 @@ object VectorVsArray extends App {
       { _ =>
         util.Random.nextInt()
       },
-      islandCount    = PositiveCount(15),
       populationSize = PositiveCount(1000),
+      islandCount    = PositiveCount(15),
+      mutationRate   = Solver.DEFAULT_MUTATION_RATE,
       generations    = PositiveCount(40)
     )
 
@@ -38,8 +39,9 @@ object VectorVsArray extends App {
       { _ =>
         util.Random.nextInt()
       },
-      islandCount    = PositiveCount(15),
       populationSize = PositiveCount(1000),
+      islandCount    = PositiveCount(15),
+      mutationRate   = Solver.DEFAULT_MUTATION_RATE,
       generations    = PositiveCount(40)
     )
 
@@ -48,29 +50,31 @@ object VectorVsArray extends App {
 
   def withVector(): Unit = {
     implicit val combinator =
-      new DiscreteFixedLengthCombinator((1 to 100).map(WrappedInt), 100)
+      new DiscreteFixedLengthCombinator((1 to 100).map(WrappedInt.apply), 100)
 
     val solver = new Solver[Seq[WrappedInt], Int](
       { _ =>
         util.Random.nextInt()
       },
-      islandCount    = PositiveCount(15),
       populationSize = PositiveCount(1000),
+      islandCount    = PositiveCount(15),
+      mutationRate   = Solver.DEFAULT_MUTATION_RATE,
       generations    = PositiveCount(40)
     )
 
     val _ = solver.solveNow
   }
 
   def withArray(): Unit = {
-    implicit val combinator = new specialized.DiscreteFixedLengthCombinator((1 to 100).map(WrappedInt), 100)
+    implicit val combinator = new specialized.DiscreteFixedLengthCombinator((1 to 100).map(WrappedInt.apply), 100)
 
     val solver = new Solver[Seq[WrappedInt], Int](
       { _ =>
         util.Random.nextInt()
       },
-      islandCount    = PositiveCount(15),
       populationSize = PositiveCount(1000),
+      islandCount    = PositiveCount(15),
+      mutationRate   = Solver.DEFAULT_MUTATION_RATE,
       generations    = PositiveCount(40)
     )
 

project/DependenciesPlugin.scala

@@ -13,14 +13,13 @@ object DependenciesPlugin extends AutoPlugin {
       def withEffectMonad: Project =
         p.settings(libraryDependencies += "org.typelevel" %% "cats-effect" % Versions.catsEffect)
 
-      def withTesting: Project = {
+      def withTesting: Project =
         p.settings(
           libraryDependencies ++= Seq(
             "org.typelevel" %% "weaver-cats"       % Versions.weaver % Test,
             "org.typelevel" %% "weaver-scalacheck" % Versions.weaver % Test
           )
         )
-      }
 
       def withYaml: Project =
         p.settings(

spawning-pool-core-alpha/src/test/scala/com/htmlism/spawningpool/fitness/FitnessSpec.scala

@@ -1,42 +1,42 @@
 package com.htmlism.spawningpool.fitness
 
+import scala.annotation.nowarn
+
 import org.specs2.mutable.Specification
 
+@nowarn("msg=unused value")
+@SuppressWarnings(Array("org.wartremover.warts.NonUnitStatements", "org.wartremover.warts.Unused"))
 class FitnessSpec extends Specification {
   "fitness by ordering" should {
+    val fitness = new OrdinalFitness[(String, Int)]
     "summon the implicit ordering" in {
-      val fitness = new OrdinalFitness[(String, Int)]
-
-      fitness.compare("a" -> 1, "a" -> 2) === -1
-      fitness.compare("a" -> 1, "a" -> 1) === 0
-      fitness.compare("b" -> 1, "a" -> 2) === 1
+      fitness.compare("a" -> 1, "a" -> 2) must_== -1
+      fitness.compare("a" -> 1, "a" -> 1) must_== 0
+      fitness.compare("b" -> 1, "a" -> 2) must_== 1
     }
   }
 
   "ratio fitness" should {
+    val fitness = new RatioFitness((s: String) => s.length)
     "summon the implicit numeric" in {
-      val fitness = new RatioFitness((s: String) => s.length)
-
-      fitness.compare("short", "longest") === -1
-      fitness.compare("equal", "apple") === 0
-      fitness.compare("longest", "short") === 1
+      fitness.compare("short", "longest") must_== -1
+      fitness.compare("equal", "apple") must_== 0
+      fitness.compare("longest", "short") must_== 1
     }
   }
 
   "fitness" should {
+    val fitness = new OrdinalFitness[Int]
     "support minimization" in {
-      val fitness = new OrdinalFitness[Int]
-
-      fitness.compare(123, 45) === 1
-      fitness.minimize.compare(123, 45) === -1
+      fitness.compare(123, 45) must_== 1
+      fitness.minimize.compare(123, 45) must_== -1
     }
 
     "support chaining" in {
       val fitness1     = new OrdinalFitness[Int]
       val fitness2     = new OrdinalFitness[Double]
       val totalFitness = fitness1 andThen fitness2
-
-      totalFitness.compare((1, 1d), (1, 2d)) === -1
+      totalFitness.compare((1, 1d), (1, 2d)) must_== -1
     }
   }
 }

spawning-pool-core/src/main/scala/com/htmlism/spawningpool/Crossover.scala

@@ -23,9 +23,9 @@ trait Crossover[A] {
 }
 
 object IntUniformCrossover extends Crossover[Int] {
-  def crossover(xs: List[Int]): Int = ???
+  def crossover(xs: List[Int]): Int = sys.error("crossover not implemented")
 }
 
 object DoubleUniformCrossover extends Crossover[Double] {
-  def crossover(xs: List[Double]): Double = ???
+  def crossover(xs: List[Double]): Double = sys.error("crossover not implemented")
 }

spawning-pool-core/src/main/scala/com/htmlism/spawningpool/Mutation.scala

@@ -29,13 +29,13 @@ object IntMutation extends Mutation[Int] {
 }
 
 object DoubleMutation extends Mutation[Double] {
-  def mutate(x: Double): Double = ???
+  def mutate(x: Double): Double = sys.error("mutate not implemented")
 }
 
 object FixedArrayIntMutation extends Mutation[Array[Int]] {
-  def mutate(x: Array[Int]): Array[Int] = ???
+  def mutate(x: Array[Int]): Array[Int] = sys.error("mutate not implemented")
 }
 
 object FixedDoubleMutation extends Mutation[Array[Double]] {
-  def mutate(x: Array[Double]): Array[Double] = ???
+  def mutate(x: Array[Double]): Array[Double] = sys.error("mutate not implemented")
 }

spawning-pool-core/src/main/scala/com/htmlism/spawningpool/PositiveCount.scala

@@ -5,7 +5,7 @@ object PositiveCount {
     if (count > 0)
       new PositiveCount(count)
     else
-      throw new IllegalArgumentException(s"$count is not positive")
+      sys.error(s"$count is not positive")
 }
 
 class PositiveCount private (val count: Int) extends AnyVal {

spawning-pool-core/src/main/scala/com/htmlism/spawningpool/Solver.scala

@@ -10,6 +10,11 @@ object Solver {
   val DEFAULT_GENERATION_COUNT = PositiveCount(20)
   val DEFAULT_MUTATION_RATE    = .01
 
+  def apply[A, B](
+      fitness: A => B
+  )(implicit evolver: Evolver[A], ordering: Ordering[B]): Solver[A, B] =
+    new Solver(fitness, DEFAULT_POPULATION_SIZE, DEFAULT_ISLAND_COUNT, DEFAULT_MUTATION_RATE, DEFAULT_GENERATION_COUNT)
+
   def randomIndividual[A](population: Seq[A])(implicit rig: RandomIndexProvider): A =
     population(rig.randomIndex(population.size))
 
@@ -77,10 +82,10 @@ object Solver {
   */
 class Solver[A, B](
     fitness: A => B,
-    populationSize: PositiveCount = Solver.DEFAULT_POPULATION_SIZE,
-    islandCount: PositiveCount    = Solver.DEFAULT_ISLAND_COUNT,
-    mutationRate: Double          = Solver.DEFAULT_MUTATION_RATE,
-    generations: PositiveCount    = Solver.DEFAULT_GENERATION_COUNT
+    populationSize: PositiveCount,
+    islandCount: PositiveCount,
+    mutationRate: Double,
+    generations: PositiveCount
 )(implicit evolver: Evolver[A], ordering: Ordering[B]) {
   import com.htmlism.spawningpool.Solver.*
 
@@ -95,7 +100,7 @@ class Solver[A, B](
   def solve(seed: List[A])(implicit ec: ExecutionContext): Future[Solutions] =
     Future {
       if (seed.isEmpty)
-        throw new IllegalArgumentException("must provide a non-empty collection as a seed")
+        sys.error("must provide a non-empty collection as a seed")
       else
         evolveFrom {
           seed.toVector
@@ -122,7 +127,13 @@ class Solver[A, B](
       f.map { ctx =>
         val byFitness = ctx.population.groupBy(ctx.fitness)
 
-        byFitness(byFitness.keys.max)
+        val maxKey = byFitness
+          .keys
+          .headOption
+          .fold(sys.error("empty population"))(head =>
+            byFitness.keys.foldLeft(head)((a, b) => if (ctx.ordering.compare(a, b) >= 0) a else b)
+          )
+        byFitness(maxKey)
       }
     }
 

spawning-pool-core/src/main/scala/com/htmlism/spawningpool/combinatorics/DefaultRandomProvider.scala

@@ -10,7 +10,7 @@ trait DefaultRandomProvider
     with LengthProvider
     with VariationProvider
     with MutationMethodProvider {
-  private val rng       = new util.Random
+  private val rng                                   = new util.Random
   private val mutations: IndexedSeq[MutationMethod] =
     IndexedSeq[MutationMethod](MutateGene, AddGene, RemoveGene)
 

spawning-pool-core/src/test/scala/com/htmlism/spawningpool/GeneratorSpec.scala

@@ -1,7 +1,11 @@
 package com.htmlism.spawningpool
 
+import scala.annotation.nowarn
+
 import org.specs2.mutable.Specification
 
+@nowarn("msg=unused value")
+@SuppressWarnings(Array("org.wartremover.warts.NonUnitStatements", "org.wartremover.warts.Unused"))
 class GeneratorSpec extends Specification {
   "Generation" should {
     "provide default implementations" in {