Fix Codacy warnings.

Author: sshevchenko

benchmark/src/main/scala/com/evolutiongaming/concurrent/sequentially/SequentiallyCatsVsAkkaBenchmark.scala

@@ -50,6 +50,7 @@ class SequentiallyCatsVsAkkaBenchmark extends Common {
     implicit val ec: scala.concurrent.ExecutionContext = akkaSystem.dispatcher
     val futures = List.fill(BatchSize)(akkaSequentially(Random.nextInt()) {})
     Await.result(Future.sequence(futures), 10.seconds)
+    ()
   }
 
   @Benchmark
@@ -58,13 +59,15 @@ class SequentiallyCatsVsAkkaBenchmark extends Common {
       catsSequentially.applyF(Random.nextInt())(IO.unit)
     )
     operations.sequence.unsafeRunSync()(runtime)
+    ()
   }
 
   @Benchmark
   def catsApplyFuture(): Unit = {
     implicit val ec: scala.concurrent.ExecutionContext = scala.concurrent.ExecutionContext.global
     val futures = List.fill(BatchSize)(catsSequentially(Random.nextInt()) {}(dispatcher))
     Await.result(Future.sequence(futures), 10.seconds)
+    ()
   }
 
   @TearDown(Level.Trial)

run-benchmarks.sh

@@ -5,8 +5,7 @@
 
 set -e
 
-# Colors for output
-RED='\033[0;31m'
+# Colors for outputCodacy
 GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
 BLUE='\033[0;34m'

sequentially-ce/src/main/scala/com/evolutiongaming/concurrent/sequentially/SequentiallyF.scala

@@ -14,10 +14,8 @@ import scala.concurrent.Future
   * - Number of buckets: (availableProcessors max 1) * 5
   * - All semaphores are pre-allocated at initialization
   */
-final class SequentiallyF[F[_], K] private (
+final class SequentiallyF[F[_] : Async, K] private (
   semaphores: Vector[Semaphore[F]]
-)(implicit
-  F: Async[F]
 ) {
 
   private val bucketCount = semaphores.size
@@ -45,7 +43,7 @@ final class SequentiallyF[F[_], K] private (
     dispatcher: Dispatcher[F]
   ): Future[T] = {
     val semaphore = semaphores(getBucket(key))
-    val run: F[T] = semaphore.permit.use(_ => F.delay(task))
+    val run: F[T] = semaphore.permit.use(_ => Async[F].delay(task))
     dispatcher.unsafeToFuture(run)
   }
 

sequentially-ce/src/test/scala/com/evolutiongaming/concurrent/sequentially/SequentiallyCatsSpec.scala

@@ -21,8 +21,12 @@ class SequentiallyFSpec extends AnyWordSpec with Matchers with ScalaFutures with
     interval = Span(50, Millis),
   )
 
-  implicit val dispatcher: Dispatcher[IO] =
-    Dispatcher.parallel[IO].allocated.unsafeRunSync()(IORuntime.global)._1
+  implicit val dispatcher: Dispatcher[IO] = createDispatcher
+
+  private def createDispatcher: Dispatcher[IO] = {
+    val (dispatcher, _) = Dispatcher.parallel[IO].allocated.unsafeRunSync()(IORuntime.global)
+    dispatcher
+  }
 
   "SequentiallyF" should {
 
@@ -170,7 +174,7 @@ class SequentiallyFSpec extends AnyWordSpec with Matchers with ScalaFutures with
       val semaphores = List.fill(bucketCount)(Semaphore[IO](1)).sequence.map(_.toVector).unsafeRunSync()
       implicit val (dispatcher: Dispatcher[IO], dispatcherCleanup: IO[Unit]) =
         Dispatcher.parallel[IO].allocated.unsafeRunSync()
-      val sequentially = SequentiallyF.resource[IO, Int](semaphores).allocated.unsafeRunSync()._1
+      val (sequentially, _) = SequentiallyF.resource[IO, Int](semaphores).allocated.unsafeRunSync()
 
       try {
         // Verify all semaphores are initialized