From e5eebd44dc139e2aba13f1989e394400f23be096 Mon Sep 17 00:00:00 2001 From: Ragnar Englund Date: Sun, 7 Apr 2024 19:24:14 +0200 Subject: [PATCH] formatting --- .../io/github/ragazoor/IOBenchmark.scala | 6 ++--- .../scala/io/github/ragazoor/Attempt.scala | 16 ++++++------ .../scala/io/github/ragazoor/Future.scala | 2 +- .../ragazoor/migration/IoToStdFuture.scala | 26 +++++++++++++++++-- .../github/ragazoor/migration/implicits.scala | 2 +- .../io/github/ragazoor/AttemptSpec.scala | 11 +++++--- 6 files changed, 44 insertions(+), 19 deletions(-) diff --git a/benchmark/src/main/scala/io/github/ragazoor/IOBenchmark.scala b/benchmark/src/main/scala/io/github/ragazoor/IOBenchmark.scala index 066ff1c..4bb1284 100644 --- a/benchmark/src/main/scala/io/github/ragazoor/IOBenchmark.scala +++ b/benchmark/src/main/scala/io/github/ragazoor/IOBenchmark.scala @@ -43,7 +43,7 @@ class IOBenchmark { await(futureFlatMapRec(recursion, StdFuture.successful(1))) @tailrec private[this] final def resultFlatMapRec(i: Int, f: Attempt[Nothing, Int])(implicit - ec: ExecutionContext + ec: ExecutionContext ): Attempt[Nothing, Int] = if (i > 0) resultFlatMapRec(i - 1, f.flatMap(Attempt.successful)(ec))(ec) else f @@ -61,7 +61,7 @@ class IOBenchmark { await(futureMapRec(recursion, StdFuture.successful(1))) @tailrec private[this] final def resultMapRec(i: Int, f: Attempt[Nothing, Int])(implicit - ec: ExecutionContext + ec: ExecutionContext ): Attempt[Nothing, Int] = if (i > 0) resultMapRec(i - 1, f.map(identity)(ec))(ec) else f @@ -76,7 +76,7 @@ class IOBenchmark { else f @tailrec private[this] final def resultMapErrorRec(i: Int, f: Attempt[RuntimeException, Int])(implicit - ec: ExecutionContext + ec: ExecutionContext ): Attempt[RuntimeException, Int] = if (i > 0) resultMapErrorRec(i - 1, f.mapError(identity)(ec))(ec) else f diff --git a/result/src/main/scala/io/github/ragazoor/Attempt.scala b/result/src/main/scala/io/github/ragazoor/Attempt.scala index 86d7667..fbd5753 100644 --- a/result/src/main/scala/io/github/ragazoor/Attempt.scala +++ b/result/src/main/scala/io/github/ragazoor/Attempt.scala @@ -1,12 +1,12 @@ package io.github.ragazoor -import io.github.ragazoor.AttemptUtils.{failedFailure, zipWithTuple2Fun} +import io.github.ragazoor.AttemptUtils.{ failedFailure, zipWithTuple2Fun } import scala.concurrent.ExecutionContext.parasitic import scala.concurrent.duration.Duration -import scala.concurrent.{Awaitable, CanAwait, ExecutionContext, TimeoutException, Future => StdFuture} +import scala.concurrent.{ Awaitable, CanAwait, ExecutionContext, Future => StdFuture, TimeoutException } import scala.util.control.NonFatal -import scala.util.{Failure, Success, Try} +import scala.util.{ Failure, Success, Try } sealed trait Attempt[+E <: Throwable, +A] extends Awaitable[A] { self => @@ -46,12 +46,12 @@ sealed trait Attempt[+E <: Throwable, +A] extends Awaitable[A] { zipWith(that)(zipWithTuple2Fun)(parasitic) def zipWith[E2 >: E <: Throwable, U, R](that: Attempt[E2, U])(f: (A, U) => R)(implicit - ec: ExecutionContext + ec: ExecutionContext ): Attempt[E2, R] = Attempt(self.toFuture.zipWith(that.toFuture)(f), isFatal || that.isFatal) def catchAll[E2 >: E <: Throwable, A2 >: A](f: E => Attempt[E2, A2])(implicit - ec: ExecutionContext + ec: ExecutionContext ): Attempt[E2, A2] = { var isFutureFatal = isFatal val transformedFuture = self.toFuture.transformWith { @@ -65,7 +65,7 @@ sealed trait Attempt[+E <: Throwable, +A] extends Awaitable[A] { } def catchSome[E2 >: E <: Throwable, A2 >: A](pf: PartialFunction[E, Attempt[E2, A2]])(implicit - ec: ExecutionContext + ec: ExecutionContext ): Attempt[E2, A2] = { val transformedFuture = self.toFuture.transformWith { case Failure(e) if NonFatal(e) && pf.isDefinedAt(e.asInstanceOf[E]) && !isFatal => @@ -98,7 +98,7 @@ sealed trait Attempt[+E <: Throwable, +A] extends Awaitable[A] { Attempt(self.toFuture.transform(f), isFatal) def transformWith[E2 >: E <: Throwable, B](f: Try[A] => Attempt[E2, B])(implicit - executor: ExecutionContext + executor: ExecutionContext ): Attempt[E2, B] = Attempt(self.toFuture.transformWith(f(_).toFuture), isFatal) @@ -166,7 +166,7 @@ object Attempt { } final def sequence[E <: Throwable, A](results: Seq[Attempt[E, A]])(implicit - ec: ExecutionContext + ec: ExecutionContext ): Attempt[E, Seq[A]] = Attempt(StdFuture.sequence(results.map(_.toFuture)), fatal = false) diff --git a/result/src/main/scala/io/github/ragazoor/Future.scala b/result/src/main/scala/io/github/ragazoor/Future.scala index 5cac3b0..9463d9a 100644 --- a/result/src/main/scala/io/github/ragazoor/Future.scala +++ b/result/src/main/scala/io/github/ragazoor/Future.scala @@ -1,6 +1,6 @@ package io.github.ragazoor -import scala.concurrent.{ExecutionContext, Future => StdFuture} +import scala.concurrent.{ ExecutionContext, Future => StdFuture } import scala.util.Try /* diff --git a/result/src/main/scala/io/github/ragazoor/migration/IoToStdFuture.scala b/result/src/main/scala/io/github/ragazoor/migration/IoToStdFuture.scala index f71585a..57779ab 100644 --- a/result/src/main/scala/io/github/ragazoor/migration/IoToStdFuture.scala +++ b/result/src/main/scala/io/github/ragazoor/migration/IoToStdFuture.scala @@ -2,7 +2,7 @@ package io.github.ragazoor.migration import io.github.ragazoor.Attempt -import scala.concurrent.{Future => StdFuture} +import scala.concurrent.{ Future => StdFuture } import scala.language.implicitConversions trait IoToStdFuture { @@ -244,7 +244,29 @@ trait IoToStdFuture { X21, B ]( - f21: (X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21) => Attempt[E, B] + f21: ( + X1, + X2, + X3, + X4, + X5, + X6, + X7, + X8, + X9, + X10, + X11, + X12, + X13, + X14, + X15, + X16, + X17, + X18, + X19, + X20, + X21 + ) => Attempt[E, B] ): (X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21) => StdFuture[B] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21) => f21(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21).toFuture diff --git a/result/src/main/scala/io/github/ragazoor/migration/implicits.scala b/result/src/main/scala/io/github/ragazoor/migration/implicits.scala index 3627fa7..388f8a9 100644 --- a/result/src/main/scala/io/github/ragazoor/migration/implicits.scala +++ b/result/src/main/scala/io/github/ragazoor/migration/implicits.scala @@ -2,7 +2,7 @@ package io.github.ragazoor.migration import io.github.ragazoor.Attempt -import scala.concurrent.{Future => StdFuture} +import scala.concurrent.{ Future => StdFuture } import scala.language.implicitConversions object implicits extends IoToStdFuture { diff --git a/result/src/test/scala/io/github/ragazoor/AttemptSpec.scala b/result/src/test/scala/io/github/ragazoor/AttemptSpec.scala index ce35570..ed7efaf 100644 --- a/result/src/test/scala/io/github/ragazoor/AttemptSpec.scala +++ b/result/src/test/scala/io/github/ragazoor/AttemptSpec.scala @@ -2,7 +2,7 @@ package io.github.ragazoor import munit.FunSuite -import scala.concurrent.{Future => StdFuture} +import scala.concurrent.{ Future => StdFuture } import scala.util.Try class AttemptSpec extends FunSuite { @@ -170,13 +170,15 @@ class AttemptSpec extends FunSuite { } test("Future.mapEither") { - Attempt.successful(1) + Attempt + .successful(1) .mapEither(_ => Right(2)) .map(result => assert(result == 2)) } test("Future.mapEither, with typed error") { - Attempt.successful(1) + Attempt + .successful(1) .mapEither[RuntimeException, Int](_ => Left(new RuntimeException("Test message"))) .map(_ => assert(false)) .catchSome { case _: RuntimeException => @@ -185,7 +187,8 @@ class AttemptSpec extends FunSuite { } test("Future.mapTry") { - Attempt.successful(1) + Attempt + .successful(1) .mapTry(_ => Try(2)) .map(result => assert(result == 2)) }