Reformat with scalafmt 3.8.0

Executed command: scalafmt --non-interactive

common/shared/src/main/scala/org/specs2/control/Operation.scala

@@ -87,8 +87,7 @@ case class Operation[A](operation: () => Throwable Either A, last: Vector[Finali
         try Right(run)
         catch {
           case NonFatal(t) => Right(Left(t))
-        },
-      last
+        }, last
     )
 
   def toAction: Action[A] =

common/shared/src/main/scala/org/specs2/control/producer/Producer.scala

@@ -306,8 +306,7 @@ case class Producer[F[_]: Monad: Safe, A](run: F[LazyList[F, A]]):
             case Done() => onLastState(s) >> done[F, A].run
             case One(a) => onLastState(s) >> one[F, A](a).run
             case More(as, next) =>
-              val newS = as.foldLeft(s)(f)
-              (emit[F, A](as) `append` go(next, newS)).run
+              val newS = as.foldLeft(s)(f)(emit[F, A](as) `append` go(next, newS)).run
           }
         }
 
@@ -364,8 +363,9 @@ case class Producer[F[_]: Monad: Safe, A](run: F[LazyList[F, A]]):
     def go(p: Producer[F, A], previous: Vector[A]): Producer[F, (List[A], A)] =
       Producer(p.peek flatMap {
         case (Some(a), as) =>
-          val ps = if previous.size < n then previous else previous.drop(1)
-          (one[F, (List[A], A)]((previous.take(n).toList, a)) `append` go(as, ps :+ a)).run
+          val ps =
+            if previous.size < n then previous
+            else previous.drop(1)(one[F, (List[A], A)]((previous.take(n).toList, a)) `append` go(as, ps :+ a)).run
         case (_, _) =>
           done[F, (List[A], A)].run
       })
@@ -445,8 +445,10 @@ case class Producer[F[_]: Monad: Safe, A](run: F[LazyList[F, A]]):
         case Done() => done[F, B].run
         case One(a) => one[F, B](f(previous, a)).run
         case More(as, next) =>
-          val scanned = as.scanLeft(previous)(f).drop(1)
-          (emit[F, B](scanned) `append` go(next, scanned.lastOption.getOrElse(previous))).run
+          val scanned = as
+            .scanLeft(previous)(f)
+            .drop(1)(emit[F, B](scanned) `append` go(next, scanned.lastOption.getOrElse(previous)))
+            .run
       })
 
     one[F, B](start) `append` go(this, start)
@@ -458,11 +460,12 @@ case class Producer[F[_]: Monad: Safe, A](run: F[LazyList[F, A]]):
         case Done() => done[F, B].run
         case One(a) => one[F, B](f(a, s)._1).run
         case More(as, next) =>
-          val (bs, news) = as.foldLeft((List[B](), s)) { case ((bs1, s1), a) =>
-            val (b, s2) = f(a, s1)
-            (bs1 :+ b, s2)
-          }
-          (emit[F, B](bs) `append` go(next, news)).run
+          val (bs, news) = as
+            .foldLeft((List[B](), s)) { case ((bs1, s1), a) =>
+              val (b, s2) = f(a, s1)
+              (bs1 :+ b, s2)
+            }(emit[F, B](bs) `append` go(next, news))
+            .run
       })
     go(this, start)
 
@@ -500,8 +503,7 @@ case class Producer[F[_]: Monad: Safe, A](run: F[LazyList[F, A]]):
           as match {
             case List() => go(next, s).run
             case a :: rest =>
-              val (b, s1) = f(a, s)
-              (one[F, F[B]](b) `append` go(emit[F, A](rest) `append` next, s1)).run
+              val (b, s1) = f(a, s)(one[F, F[B]](b) `append` go(emit[F, A](rest) `append` next, s1)).run
           }
       })
 
@@ -561,11 +563,13 @@ case class Producer[F[_]: Monad: Safe, A](run: F[LazyList[F, A]]):
           }
 
         case More(as, next) =>
-          val (bs, news) = as.drop(1).foldLeft(f(as.head, s)) { case ((pb, s1), a) =>
-            val (pb1, s2) = f(a, s1)
-            (pb `append` pb1, s2)
-          }
-          (bs `append` go(next, news)).run
+          val (bs, news) = as
+            .drop(1)
+            .foldLeft(f(as.head, s)) { case ((pb, s1), a) =>
+              val (pb1, s2) = f(a, s1)
+              (pb `append` pb1, s2)
+            }(bs `append` go(next, news))
+            .run
       })
     go(this, start)
 

core/shared/src/main/scala/org/specs2/specification/process/Selector.scala

@@ -68,8 +68,7 @@ case class DefaultSelector(commandLineArguments: Arguments) extends Selector:
 
         case (fragment, sections) if !Fragment.isFormatting(fragment) && !Fragment.isEmptyText(fragment) =>
           val apply = sections.sumAll
-          val keep = apply.keep(arguments, apply.names)
-          (List(newLine, fragment).filter(_ => keep), sections)
+          val keep = apply.keep(arguments, apply.names)(List(newLine, fragment).filter(_ => keep), sections)
 
         case (fragment, sections) =>
           (List(), sections)