Merge pull request #256 from TinkoffCreditSystems/scalafmt_bump

Bump project version, upgraded scalafmt

.scalafmt.conf

@@ -1,8 +1,9 @@
+preset=default
 binPack.parentConstructors = true
 maxColumn = 120
 includeCurlyBraceInSelectChains = false
-align = most
-version = "2.4.2"
+align.preset = most
+version = "2.5.2"
 trailingCommas = preserve
 newlines.penalizeSingleSelectMultiArgList = false
 newlines.alwaysBeforeMultilineDef = false

build.sbt

@@ -1,7 +1,7 @@
 import Publish._, Dependencies._
 import com.typesafe.sbt.SbtGit.git
 
-val libVersion = "0.7.4"
+val libVersion = "0.7.5"
 
 lazy val setMinorVersion = minorVersion := {
   CrossVersion.partialVersion(scalaVersion.value) match {
@@ -322,7 +322,7 @@ lazy val simulacrumOptions = Seq(
 )
 
 lazy val defaultScalacOptions = scalacOptions ++= Seq(
-  "-deprecation", // Emit warning and location for usages of deprecated APIs.
+  "-deprecation",                  // Emit warning and location for usages of deprecated APIs.
   "-encoding",
   "utf-8",                         // Specify character encoding used by source files.
   "-explaintypes",                 // Explain type errors in more detail.

concurrent/src/main/scala/tofu/concurrent/Agent.scala

@@ -74,12 +74,12 @@ object Agent {
     * that consists of [[cats.effect.concurrent.Ref]] and [[cats.effect.concurrent.Semaphore]]
     */
   final case class SemRef[F[_]: Monad: Fire, A](ref: Ref[F, A], sem: Semaphore[F]) extends Agent[F, A] {
-    def get: F[A]                          = ref.get
-    def updateM(f: A => F[A]): F[A]        = sem.withPermit(ref.get >>= (f(_) flatTap ref.set))
-    def fireUpdateM(f: A => F[A]): F[Unit] = updateM(f).fireAndForget
-    def modifyM[B](f: A => F[(B, A)]): F[B] =
+    def get: F[A]                                                          = ref.get
+    def updateM(f: A => F[A]): F[A]                                        = sem.withPermit(ref.get >>= (f(_) flatTap ref.set))
+    def fireUpdateM(f: A => F[A]): F[Unit]                                 = updateM(f).fireAndForget
+    def modifyM[B](f: A => F[(B, A)]): F[B]                                =
       sem.withPermit(ref.get >>= (f(_).flatMap { case (b, a) => ref.set(a) as b }))
-    def updateSomeM(f: PartialFunction[A, F[A]]): F[A] =
+    def updateSomeM(f: PartialFunction[A, F[A]]): F[A]                     =
       updateM(a => if (f.isDefinedAt(a)) f(a) else a.pure[F])
     def modifySomeM[B](default: B)(f: PartialFunction[A, F[(B, A)]]): F[B] =
       modifyM(a => if (f.isDefinedAt(a)) f(a) else (default, a).pure[F])
@@ -163,8 +163,7 @@ object MakeAgent {
     def of[A](a: A): I[Agent[F, A]] = mkAgent.agentOf(a)
   }
 
-  implicit def byRefAndSemaphore[I[_]: FlatMap, F[_]: Monad: Fire](
-      implicit
+  implicit def byRefAndSemaphore[I[_]: FlatMap, F[_]: Monad: Fire](implicit
       refs: MakeRef[I, F],
       sems: MakeSemaphore[I, F]
   ): MakeAgent[I, F] = new MakeAgent[I, F] {

concurrent/src/main/scala/tofu/concurrent/Atom.scala

@@ -70,21 +70,21 @@ object Atom {
   }
 
   final case class QAtom[F[_]: Applicative: Guarantee, A](qvar: QVar[F, A]) extends Atom[F, A] {
-    def get: F[A]                  = qvar.read
-    def set(a: A): F[Unit]         = getAndSet(a).void
-    def getAndSet(a: A): F[A]      = qvar.take.guaranteeAlways(qvar.put(a))
-    def update(f: A => A): F[Unit] = qvar.take.bracketIncomplete(a => qvar.put(f(a)))(qvar.put)
+    def get: F[A]                       = qvar.read
+    def set(a: A): F[Unit]              = getAndSet(a).void
+    def getAndSet(a: A): F[A]           = qvar.take.guaranteeAlways(qvar.put(a))
+    def update(f: A => A): F[Unit]      = qvar.take.bracketIncomplete(a => qvar.put(f(a)))(qvar.put)
     def modify[B](f: A => (A, B)): F[B] = qvar.take.bracketIncomplete { a =>
       val (next, res) = f(a)
       qvar.put(next) as res
     }(qvar.put)
   }
 
   private[Atom] case class FocusedAtom[F[_]: Functor, A, B](v: Atom[F, A], focus: Contains[A, B]) extends Atom[F, B] {
-    def get: F[B]                  = v.get.map(focus.get)
-    def set(b: B): F[Unit]         = v.update(focus.set(_, b))
-    def getAndSet(b: B): F[B]      = v.modify(a => (focus.set(a, b), focus.get(a)))
-    def update(f: B => B): F[Unit] = v.update(focus.update(_, f))
+    def get: F[B]                       = v.get.map(focus.get)
+    def set(b: B): F[Unit]              = v.update(focus.set(_, b))
+    def getAndSet(b: B): F[B]           = v.modify(a => (focus.set(a, b), focus.get(a)))
+    def update(f: B => B): F[Unit]      = v.update(focus.update(_, f))
     def modify[C](f: B => (B, C)): F[C] = v.modify { a =>
       val (b, c) = f(focus.get(a))
       (focus.set(a, b), c)

concurrent/src/main/scala/tofu/concurrent/ContextT.scala

@@ -16,7 +16,7 @@ trait ContextT[F[+_], C[_[_]], +A] {
   def run(c: C[ContextT[F, C, +*]]): F[A]
 }
 
-object ContextT extends ContextTInstances {
+object ContextT         extends ContextTInstances {
   private def makeLiftF[F[+_], C[_[_]]]: F ~> ContextT[F, C, *] = funKFrom[F](fa => _ => fa)
   private val liftFAny                                          = makeLiftF[Any, Any]
 

concurrent/src/main/scala/tofu/concurrent/Daemon.scala

@@ -29,16 +29,16 @@ object Daemonic extends DaemonicInstances {
     new Daemonic[F, E] {
       override def daemonize[A](process: F[A]): F[Daemon[F, E, A]] =
         for {
-          exit <- MakeDeferred.tryable[F, Exit[E, A]]
-          ref  <- Refs[F].of(none[A])
+          exit  <- MakeDeferred.tryable[F, Exit[E, A]]
+          ref   <- Refs[F].of(none[A])
           fiber <- process
-                    .flatTap(a => ref.set(a.some))
-                    .guaranteeCase {
-                      case ExitCase.Completed => ref.get.flatMap(opt => exit.complete(Exit.Completed(opt.get)))
-                      case ExitCase.Canceled  => exit.complete(Exit.Canceled)
-                      case ExitCase.Error(e)  => exit.complete(Exit.Error(e))
-                    }
-                    .start
+                     .flatTap(a => ref.set(a.some))
+                     .guaranteeCase {
+                       case ExitCase.Completed => ref.get.flatMap(opt => exit.complete(Exit.Completed(opt.get)))
+                       case ExitCase.Canceled  => exit.complete(Exit.Canceled)
+                       case ExitCase.Error(e)  => exit.complete(Exit.Error(e))
+                     }
+                     .start
         } yield maker(fiber, exit)
     }
 
@@ -60,7 +60,7 @@ trait DaemonicInstances { self: Daemonic.type =>
     )
 }
 
-trait Daemon[F[_], E, A] extends Fiber[F, A] {
+trait Daemon[F[_], E, A] extends Fiber[F, A]     {
   def join: F[A]
   def cancel: F[Unit]
   def poll: F[Option[Exit[E, A]]]
@@ -70,7 +70,7 @@ trait Daemon[F[_], E, A] extends Fiber[F, A] {
 }
 
 /** Probably Infinite processes */
-object Daemon extends DaemonInstances {
+object Daemon            extends DaemonInstances {
   private[tofu] class Impl[F[_], E, A](process: Fiber[F, A], end: TryableDeferred[F, Exit[E, A]])
       extends Daemon[F, E, A] {
 
@@ -157,13 +157,13 @@ object Actor {
 
   def spawn[F[_]: MVars: Monad: Daemonic[*[_], E], E, A](behavior: Behavior[F, A]): F[Actor[F, E, A]] =
     for {
-      mvar <- MakeMVar[F, F].empty[A]
+      mvar                       <- MakeMVar[F, F].empty[A]
       daemon: Daemon[F, E, Void] <- Daemon.iterate(behavior)(b =>
-                                     for {
-                                       a <- mvar.take
-                                       r <- behavior.receive(a)
-                                     } yield r.getOrElse(b)
-                                   )
+                                      for {
+                                        a <- mvar.take
+                                        r <- behavior.receive(a)
+                                      } yield r.getOrElse(b)
+                                    )
     } yield new Actor(mvar, daemon)
 
   def apply[F[_]: MVars: Monad: Daemonic[*[_], E], E, A](receive: A => F[Unit]): F[Actor[F, E, A]] =
@@ -207,17 +207,17 @@ trait DaemonInstances {
 
       def zipWith[A, B, C](fa: Daemon[F, E, A], fb: Daemon[F, E, B])(f: (A, B) => C): Daemon[F, E, C] =
         new Daemon[F, E, C] {
-          def join: F[C]      = fa.join.map2(fb.join)(f)
-          def cancel: F[Unit] = fa.cancel *> fb.cancel
+          def join: F[C]                  = fa.join.map2(fb.join)(f)
+          def cancel: F[Unit]             = fa.cancel *> fb.cancel
           def poll: F[Option[Exit[E, C]]] = fa.poll.flatMap {
             case fe @ (None | Some(_: Exit.Incomplete[E])) => F.pure(fe.asInstanceOf[Option[Exit[E, C]]])
-            case Some(Exit.Completed(a)) =>
+            case Some(Exit.Completed(a))                   =>
               fb.poll.map {
                 case fe @ (None | Some(_: Exit.Incomplete[E])) => fe.asInstanceOf[Option[Exit[E, C]]]
                 case Some(Exit.Completed(b))                   => Some(Exit.Completed(f(a, b)))
               }
           }
-          def exit: F[Exit[E, C]] = fa.exit.map2(fb.exit)(_.map2(_)(f))
+          def exit: F[Exit[E, C]]         = fa.exit.map2(fb.exit)(_.map2(_)(f))
         }
     }
 }

concurrent/src/main/scala/tofu/concurrent/Exit.scala

@@ -13,13 +13,13 @@ object Exit {
 
   sealed trait Incomplete[+E] extends Exit[E, Nothing]
 
-  case object Canceled extends Incomplete[Nothing] {
+  case object Canceled                 extends Incomplete[Nothing] {
     def exitCase = ExitCase.Canceled
   }
-  final case class Error[+E](e: E) extends Incomplete[E] {
+  final case class Error[+E](e: E)     extends Incomplete[E]       {
     def exitCase = ExitCase.Error(e)
   }
-  final case class Completed[+A](a: A) extends Exit[Nothing, A] {
+  final case class Completed[+A](a: A) extends Exit[Nothing, A]    {
     override def exitCase = ExitCase.Completed
   }
 
@@ -30,17 +30,17 @@ object Exit {
         case Error(e)     => G.pure(Error(e))
         case Completed(a) => f(a).map(Completed(_))
       }
-    def foldLeft[A, B](fa: Exit[Any, A], b: B)(f: (B, A) => B): B =
+    def foldLeft[A, B](fa: Exit[Any, A], b: B)(f: (B, A) => B): B                                         =
       fa match {
         case Canceled | Error(_) => b
         case Completed(a)        => f(b, a)
       }
-    def foldRight[A, B](fa: Exit[Any, A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B] =
+    def foldRight[A, B](fa: Exit[Any, A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B]               =
       fa match {
         case Canceled | Error(_) => lb
         case Completed(a)        => f(a, lb)
       }
-    override def map[A, B](fa: Exit[Any, A])(f: A => B): Exit[Any, B] =
+    override def map[A, B](fa: Exit[Any, A])(f: A => B): Exit[Any, B]                                     =
       fa match {
         case Canceled      => Canceled
         case e: Error[Any] => e
@@ -51,14 +51,14 @@ object Exit {
       fa match {
         case Canceled        => Canceled
         case err: Error[Any] => err
-        case Completed(a) =>
+        case Completed(a)    =>
           fb match {
             case Canceled        => Canceled
             case err: Error[Any] => err
             case Completed(b)    => Completed(f(a, b))
           }
       }
-    def pure[A](x: A): Exit[Any, A] = Completed(x)
+    def pure[A](x: A): Exit[Any, A]                                                        = Completed(x)
   }
 
   implicit def exitInstance[E]: Traverse[Exit[E, *]] with Applicative[Exit[E, *]] =

concurrent/src/main/scala/tofu/concurrent/Gatekeeper.scala

@@ -61,9 +61,9 @@ object Gatekeeper {
     }
 
   final case class StoplightBySemaphore[F[_]: BracketThrow](semaphore: Semaphore[F]) extends Gatekeeper[F, Long] {
-    override def available: F[Long]           = semaphore.available
-    override def taken: F[Long]               = semaphore.count
-    override def withPermit[B](t: F[B]): F[B] = semaphore.withPermit(t)
+    override def available: F[Long]                        = semaphore.available
+    override def taken: F[Long]                            = semaphore.count
+    override def withPermit[B](t: F[B]): F[B]              = semaphore.withPermit(t)
     override def withPermitN[B](take: Long)(t: F[B]): F[B] =
       semaphore.acquireN(take).bracket(_ => t)(_ => semaphore.releaseN(take))
   }

concurrent/src/main/scala/tofu/concurrent/ReadWrite.scala

@@ -160,25 +160,25 @@ object ReadWrite {
         state.modify {
           case s @ State(q, r, false, _, _, a) if r < maxReaders && q.headOption.forall(!_.isWriter) =>
             s.copy(currentReaders = r + 1) -> d.complete(a -> releaseRead)
-          case s @ State(q, _, _, _, _, _) => s.copy(q = q :+ Reader(d)) -> F.unit
+          case s @ State(q, _, _, _, _, _)                                                           => s.copy(q = q :+ Reader(d)) -> F.unit
         }.flatten *> d.get
       } {
         case (d, ExitCase.Canceled | ExitCase.Error(_)) =>
           state.update(s => s.copy(trashedReaders = s.trashedReaders + d))
-        case _ => F.unit
+        case _                                          => F.unit
       }
 
     override def write: F[(A, A => F[Unit])] =
       Deferred[F, (A, A => F[Unit])].bracketCase { d =>
         state.modify {
           case s @ State(q, 0, false, _, _, a) if q.isEmpty =>
             s.copy(writeLocked = true) -> d.complete(a -> releaseWrite)
-          case s @ State(q, _, _, _, _, _) => s.copy(q = q :+ Writer(d)) -> F.unit
+          case s @ State(q, _, _, _, _, _)                  => s.copy(q = q :+ Writer(d)) -> F.unit
         }.flatten *> d.get
       } {
         case (d, ExitCase.Canceled | ExitCase.Error(_)) =>
           state.update(s => s.copy(trashedWriters = s.trashedWriters + d))
-        case _ => F.unit
+        case _                                          => F.unit
       }
 
     private def dropPrecedingTrashed(state: State[F, A]): State[F, A] =
@@ -187,7 +187,7 @@ object ReadWrite {
           dropPrecedingTrashed(state.copy(q = tl, trashedReaders = state.trashedReaders - d))
         case Writer(d) +: tl if state.trashedWriters(d) =>
           dropPrecedingTrashed(state.copy(q = tl, trashedWriters = state.trashedWriters - d))
-        case _ => state
+        case _                                          => state
       }
 
     private def extractReadersBatch(state: State[F, A], quantity: Int): (State[F, A], List[Reader[F, A]], Int) = {
@@ -200,7 +200,7 @@ object ReadWrite {
         if (remain <= 0) (state, batch, size)
         else
           dropPrecedingTrashed(state) match {
-            case s if s.q.isEmpty || s.q.head.isWriter => (state, batch, size)
+            case s if s.q.isEmpty || s.q.head.isWriter           => (state, batch, size)
             case s @ State((r @ Reader(_)) +: tl, _, _, _, _, _) =>
               impl(s.copy(q = tl), r :: batch, remain - 1, size + 1)
           }
@@ -215,17 +215,17 @@ object ReadWrite {
           case state @ State(Reader(d) +: tl, _, _, _, _, a) => state.copy(q = tl)                 -> d.complete(a -> releaseRead)
           case state @ State(Writer(d) +: tl, 1, _, _, _, a) =>
             state.copy(q = tl, currentReaders = 0, writeLocked = true) -> d.complete(a -> releaseWrite)
-          case state @ State(Writer(_) +: _, r, _, _, _, _) => state.copy(currentReaders = r - 1) -> F.unit
+          case state @ State(Writer(_) +: _, r, _, _, _, _)  => state.copy(currentReaders = r - 1) -> F.unit
         }
       }.flatten
 
     private def releaseWrite(newA: A): F[Unit] =
       state.modify {
         dropPrecedingTrashed(_) match {
-          case state @ State(q, _, _, _, _, _) if q.isEmpty => state.copy(a = newA, writeLocked = false) -> F.unit
+          case state @ State(q, _, _, _, _, _) if q.isEmpty  => state.copy(a = newA, writeLocked = false) -> F.unit
           case state @ State(Writer(d) +: tl, _, _, _, _, _) =>
             state.copy(q = tl, a = newA) -> d.complete(newA -> releaseWrite)
-          case s =>
+          case s                                             =>
             val (cleanState, readersBatch, batchSize) = extractReadersBatch(s, maxReaders)
             val readers                               = readersBatch.map(_.d.complete(newA -> releaseRead))
             cleanState.copy(a = newA, writeLocked = false, currentReaders = batchSize) -> readers.foldRight(F.unit)(
@@ -246,7 +246,7 @@ object ReadWrite {
       state.modify {
         case s @ State(q, r, false, _, _, a) if r < maxReaders && q.headOption.forall(!_.isWriter) =>
           s.copy(currentReaders = r + 1) -> (a -> releaseRead).some
-        case s => s -> none
+        case s                                                                                     => s -> none
       }
 
     override def tryWrite: F[Option[(A, A => F[Unit])]] =
@@ -271,7 +271,7 @@ object ReadWrite {
         case Some((a, putAndRelease)) =>
           val (u, b) = f(a)
           putAndRelease(u).as(b.some)
-        case _ => F.pure(none)
+        case _                        => F.pure(none)
       }
 
   }