Update scalafmt-core to 3.4.3

Author: 47erbot

.scalafmt.conf

@@ -1,6 +1,7 @@
-version=2.7.5
+version=3.4.3
 style = defaultWithAlign
 maxColumn = 100
+runner.dialect = scala213
 
 continuationIndent.callSite = 2
 
@@ -15,9 +16,9 @@ align {
   openParenDefnSite = false
 }
 
-docstrings = JavaDoc
+docstrings.style = Asterisk
 
 rewrite {
   rules = [SortImports, RedundantBraces]
   redundantBraces.maxLines = 1
-}
+}

build.sbt

@@ -1,16 +1,16 @@
 import com.jsuereth.sbtpgp.PgpKeys.publishSigned
 
-ThisBuild / organization := "org.scala-exercises"
+ThisBuild / organization       := "org.scala-exercises"
 ThisBuild / githubOrganization := "47degrees"
-ThisBuild / scalaVersion := "2.13.8"
+ThisBuild / scalaVersion       := "2.13.8"
 
 // Required to prevent errors for eviction from binary incompatible dependency
 // resolutions.
 // See also: https://github.com/scala-exercises/exercises-cats/pull/267
 ThisBuild / libraryDependencySchemes += "org.scala-lang.modules" %% "scala-xml" % "always"
 
 // This is required by the exercises compiler:
-publishLocal := (publishLocal dependsOn compile).value
+publishLocal  := (publishLocal dependsOn compile).value
 publishSigned := (publishSigned dependsOn compile).value
 
 addCommandAlias("ci-test", "scalafmtCheckAll; scalafmtSbtCheck; test")

src/main/scala/fpinscalalib/ErrorHandlingSection.scala

@@ -25,29 +25,31 @@ import org.scalatest.matchers.should.Matchers
 import scala.util.{Success, Try}
 
 /**
- * @param name handling_error_without_exceptions
+ * @param name
+ *   handling_error_without_exceptions
  */
 object ErrorHandlingSection
     extends AnyFlatSpec
     with Matchers
     with org.scalaexercises.definitions.Section {
 
   /**
-   * = Functional programming in Scala =
+   * =Functional programming in Scala=
    *
-   * The following set of sections represent the exercises contained in the book "Functional Programming in Scala",
-   * written by Paul Chiusano and Rúnar Bjarnason and published by Manning. This content library is meant to be used
-   * in tandem with the book. We use the same numeration for the exercises for you to follow them.
+   * The following set of sections represent the exercises contained in the book "Functional
+   * Programming in Scala", written by Paul Chiusano and Rúnar Bjarnason and published by Manning.
+   * This content library is meant to be used in tandem with the book. We use the same numeration
+   * for the exercises for you to follow them.
    *
-   * For more information about "Functional Programming in Scala" please visit its
-   * <a href="https://www.manning.com/books/functional-programming-in-scala">official website</a>.
+   * For more information about "Functional Programming in Scala" please visit its <a
+   * href="https://www.manning.com/books/functional-programming-in-scala">official website</a>.
    *
-   * = The Option data type =
+   * =The Option data type=
    *
    * <b>Exercise 4.1</b>:
    *
-   * We're going to look at some of the functions available in the `Option`, starting by `map`, that applies a function
-   * `f` in the `Option` is not `None`:
+   * We're going to look at some of the functions available in the `Option`, starting by `map`, that
+   * applies a function `f` in the `Option` is not `None`:
    *
    * {{{
    *   def map[B](f: A => B): Option[B] = this match {
@@ -87,7 +89,8 @@ object ErrorHandlingSection
   }
 
   /**
-   * We can also implement `flatMap`, which applies a function `f` which may also fail, to the `Option` if not `None`:
+   * We can also implement `flatMap`, which applies a function `f` which may also fail, to the
+   * `Option` if not `None`:
    *
    * {{{
    *   def flatMap[B](f: A => Option[B]): Option[B] = map(f) getOrElse None
@@ -104,8 +107,8 @@ object ErrorHandlingSection
   }
 
   /**
-   * The function `getOrElse` tries to get the value contained in the Option, but if it's a `None`, it will
-   * return the default value provided by the caller:
+   * The function `getOrElse` tries to get the value contained in the Option, but if it's a `None`,
+   * it will return the default value provided by the caller:
    *
    * {{{
    *   def getOrElse[B>:A](default: => B): B = this match {
@@ -114,8 +117,8 @@ object ErrorHandlingSection
    *   }
    * }}}
    *
-   * `orElse` returns the original `Option` if not `None`, or returns the provided `Option` as an alternative in that
-   * case:
+   * `orElse` returns the original `Option` if not `None`, or returns the provided `Option` as an
+   * alternative in that case:
    *
    * {{{
    *   def orElse[B>:A](ob: => Option[B]): Option[B] = this map (Some(_)) getOrElse ob
@@ -132,8 +135,8 @@ object ErrorHandlingSection
   }
 
   /**
-   * Finally, we can implement a `filter` function that will turn any `Option` into a `None` if it doesn't satisfy the
-   * provided predicate:
+   * Finally, we can implement a `filter` function that will turn any `Option` into a `None` if it
+   * doesn't satisfy the provided predicate:
    *
    * {{{
    *   def filter(f: A => Boolean): Option[A] = this match {
@@ -157,8 +160,8 @@ object ErrorHandlingSection
   /**
    * <b>Exercise 4.2:</b>
    *
-   * Let's implement the `variance` function in terms of `flatMap`. If the mean of a sequence is `m`, the variance
-   * is the mean of `math.pow(x - m, 2)` for each element in the sequence:
+   * Let's implement the `variance` function in terms of `flatMap`. If the mean of a sequence is
+   * `m`, the variance is the mean of `math.pow(x - m, 2)` for each element in the sequence:
    *
    * {{{
    *   def variance(xs: Seq[Double]): Option[Double] =
@@ -167,8 +170,9 @@ object ErrorHandlingSection
    *
    * <b>Exercise 4.3:</b>
    *
-   * Let's write a generic function to combine two `Option` values , so that if any of those values is `None`, the
-   * result value is too; and otherwise it will be the result of applying the provided function:
+   * Let's write a generic function to combine two `Option` values , so that if any of those values
+   * is `None`, the result value is too; and otherwise it will be the result of applying the
+   * provided function:
    *
    * {{{
    *   def map2[A,B,C](a: Option[A], b: Option[B])(f: (A, B) => C): Option[C] =
@@ -177,10 +181,10 @@ object ErrorHandlingSection
    *
    * <b>Exercise 4.4:</b>
    *
-   * Let's continue by looking at a few other similar cases. For instance, the `sequence` function, which combines a list
-   * of `Option`s into another `Option` containing a list of all the `Some`s in the original one. If the original
-   * list contains `None` at least once, the result of the function should be `None`. If not, the result should be a
-   * `Some` with a list of all the values:
+   * Let's continue by looking at a few other similar cases. For instance, the `sequence` function,
+   * which combines a list of `Option`s into another `Option` containing a list of all the `Some`s
+   * in the original one. If the original list contains `None` at least once, the result of the
+   * function should be `None`. If not, the result should be a `Some` with a list of all the values:
    *
    * {{{
    *   def sequence(a: List[Option[A]]): Option[List[A]] = a match {
@@ -199,8 +203,9 @@ object ErrorHandlingSection
   /**
    * <b>Exercise 4.5:</b>
    *
-   * The last `Option` function we're going to explore is `traverse`, that will allow us to map over a list using a
-   * function that might fail, returning `None` if applying it to any element of the list returns `None`:
+   * The last `Option` function we're going to explore is `traverse`, that will allow us to map over
+   * a list using a function that might fail, returning `None` if applying it to any element of the
+   * list returns `None`:
    *
    * {{{
    *   def traverse[A, B](a: List[A])(f: A => Option[B]): Option[List[B]] = a match {
@@ -239,12 +244,12 @@ object ErrorHandlingSection
   }
 
   /**
-   * = The Either data type =
+   * =The Either data type=
    *
    * <b>Exercise 4.6:</b>
    *
-   * As we did with `Option`, let's implement versions of `map`, `flatMap`, `orElse` and `map2` on `Either` that
-   * operate on the `Right` value, starting with `map`:
+   * As we did with `Option`, let's implement versions of `map`, `flatMap`, `orElse` and `map2` on
+   * `Either` that operate on the `Right` value, starting with `map`:
    *
    * {{{
    *   def map[B](f: A => B): Either[E, B] = this match {
@@ -253,10 +258,11 @@ object ErrorHandlingSection
    *   }
    * }}}
    *
-   * In the same fashion as `Option`, `map` allows us to chain operations on an `Either` without worrying about the
-   * possible errors that may arise, as the chain will stop if any error occurs. Let's try it out, by improving the
-   * employee lookup function we implemented before, to use `Either` instead of `Option`. Try to use `map` on the
-   * `Either` type to obtain the department of each employee:
+   * In the same fashion as `Option`, `map` allows us to chain operations on an `Either` without
+   * worrying about the possible errors that may arise, as the chain will stop if any error occurs.
+   * Let's try it out, by improving the employee lookup function we implemented before, to use
+   * `Either` instead of `Option`. Try to use `map` on the `Either` type to obtain the department of
+   * each employee:
    */
   def eitherMapAssert(res0: (Either[String, Employee]) => Either[String, String]): Unit = {
     def lookupByNameViaEither(name: String): Either[String, Employee] =
@@ -275,9 +281,9 @@ object ErrorHandlingSection
   }
 
   /**
-   * `flatMap` behaves the same in `Either` as it does in `Option`, allowing us to chain operations that may also fail.
-   * Use it to try to obtain the managers from each employee. Note that when calling our `getManager` function, we can
-   * find two different errors in its execution:
+   * `flatMap` behaves the same in `Either` as it does in `Option`, allowing us to chain operations
+   * that may also fail. Use it to try to obtain the managers from each employee. Note that when
+   * calling our `getManager` function, we can find two different errors in its execution:
    */
   def eitherFlatMapAssert(res0: Right[String], res1: Left[String], res2: Left[String]): Unit = {
     def getManager(employee: Either[String, Employee]): Either[String, String] =
@@ -294,8 +300,8 @@ object ErrorHandlingSection
   }
 
   /**
-   * `orElse` works the same as in `Option`s, returning the original `Either` when it contains a `Right`, or the
-   * provided alternative in case it's a `Left`:
+   * `orElse` works the same as in `Option`s, returning the original `Either` when it contains a
+   * `Right`, or the provided alternative in case it's a `Left`:
    *
    * {{{
    *   def orElse[EE >: E, AA >: A](b: => Either[EE, AA]): Either[EE, AA] = this match {
@@ -304,8 +310,8 @@ object ErrorHandlingSection
    *   }
    * }}}
    *
-   * Let's check out how it behaves. Let's assume that everyone inside our company ends up responding to a "Mr. CEO"
-   * manager. We can provide that logic with `orElse`:
+   * Let's check out how it behaves. Let's assume that everyone inside our company ends up
+   * responding to a "Mr. CEO" manager. We can provide that logic with `orElse`:
    */
   def eitherOrElseAssert(res0: Right[String], res1: Right[String], res2: Right[String]): Unit = {
     def getManager(employee: Either[String, Employee]): Either[String, String] =
@@ -322,8 +328,9 @@ object ErrorHandlingSection
   }
 
   /**
-   * In the same fashion as with `Option`s, `map2` lets us combine two `Either`s using a binary function. Note that we
-   * will use for-comprehensions instead of a chain of `flatMap` and `map` calls:
+   * In the same fashion as with `Option`s, `map2` lets us combine two `Either`s using a binary
+   * function. Note that we will use for-comprehensions instead of a chain of `flatMap` and `map`
+   * calls:
    *
    * {{{
    *   def map2[EE >: E, B, C](b: Either[EE, B])(f: (A, B) => C):  Either[EE, C] =
@@ -333,8 +340,8 @@ object ErrorHandlingSection
    *   } yield f(a,b1)
    * }}}
    *
-   * In this implementation, we can't report errors on both sides. To do that, we would need a new data type that can
-   * hold a list of errors:
+   * In this implementation, we can't report errors on both sides. To do that, we would need a new
+   * data type that can hold a list of errors:
    *
    * {{{
    *   trait Partial[+A,+B]
@@ -344,8 +351,8 @@ object ErrorHandlingSection
    *
    * This data type is really similar to Scalaz' `Validation` type.
    *
-   * In any case, let's test `map2` on the following exercise, to find out if two employees share a department by using
-   * an specific function:
+   * In any case, let's test `map2` on the following exercise, to find out if two employees share a
+   * department by using an specific function:
    */
   def eitherMap2Assert(res0: Right[Boolean], res1: Right[Boolean], res2: Left[String]): Unit = {
     def employeesShareDepartment(employeeA: Employee, employeeB: Employee) =
@@ -365,8 +372,8 @@ object ErrorHandlingSection
   /**
    * <b>Exercise 4.7:</b>
    *
-   * `sequence` and `traverse` can also be implemented for `Either`. Those functions should return the first error that
-   * can be found, if there is one.
+   * `sequence` and `traverse` can also be implemented for `Either`. Those functions should return
+   * the first error that can be found, if there is one.
    *
    * {{{
    *   def traverse[E,A,B](es: List[A])(f: A => Either[E, B]): Either[E, List[B]] = es match {
@@ -390,8 +397,8 @@ object ErrorHandlingSection
   }
 
   /**
-   * As for `sequence`, we can create a `List` of the employees we looked up by using the `lookupByNameViaEither`, and
-   * find out if we were looking for a missing person:
+   * As for `sequence`, we can create a `List` of the employees we looked up by using the
+   * `lookupByNameViaEither`, and find out if we were looking for a missing person:
    */
   def eitherSequenceAssert(res0: Right[List[Employee]], res1: Left[String]): Unit = {
     val employees              = List(lookupByNameViaEither("Joe"), lookupByNameViaEither("Mary"))

src/main/scala/fpinscalalib/FPinScalaLibrary.scala

@@ -19,9 +19,11 @@ package fpinscalalib
 import org.scalaexercises.definitions._
 
 /**
- * Exercises based on Manning's "Functional Programming in Scala" book by Paul Chiusano and Rúnar Bjarnason.
+ * Exercises based on Manning's "Functional Programming in Scala" book by Paul Chiusano and Rúnar
+ * Bjarnason.
  *
- * @param name fp_in_scala
+ * @param name
+ *   fp_in_scala
  */
 object FPinScalaLibrary extends Library {
   override def owner      = "scala-exercises"