Update scalafmt-core to 2.6.0

Author: BenFradet

.scalafmt.conf

@@ -1,4 +1,4 @@
-version=2.5.3
+version=2.6.0
 style = defaultWithAlign
 maxColumn = 100
 

src/main/scala/catslib/Applicative.scala

@@ -22,26 +22,26 @@ import org.scalatest.flatspec.AnyFlatSpec
 import cats._
 import cats.implicits._
 
-/** `Applicative` extends `Apply` by adding a single method, `pure`:
+/**
+ * `Applicative` extends `Apply` by adding a single method, `pure`:
  *
  * {{{
  * def pure[A](x: A): F[A]
  * }}}
  *
- *
  * @param name applicative
  */
 object ApplicativeSection
     extends AnyFlatSpec
     with Matchers
     with org.scalaexercises.definitions.Section {
 
-  /** This method takes any value and returns the value in the context of
+  /**
+   * This method takes any value and returns the value in the context of
    * the functor. For many familiar functors, how to do this is
    * obvious. For `Option`, the `pure` operation wraps the value in
    * `Some`. For `List`, the `pure` operation returns a single element
    * `List`:
-   *
    */
   def pureMethod(res0: Option[Int], res1: List[Int]) = {
     import cats._
@@ -51,7 +51,8 @@ object ApplicativeSection
     Applicative[List].pure(1) should be(res1)
   }
 
-  /** Like `Functor` and `Apply`, `Applicative`
+  /**
+   * Like `Functor` and `Apply`, `Applicative`
    * functors also compose naturally with each other. When
    * you compose one `Applicative` with another, the resulting `pure`
    * operation will lift the passed value into one context, and the result
@@ -60,7 +61,8 @@ object ApplicativeSection
   def applicativeComposition(res0: List[Option[Int]]) =
     (Applicative[List] compose Applicative[Option]).pure(1) should be(res0)
 
-  /** = Applicative Functors & Monads =
+  /**
+   * = Applicative Functors & Monads =
    *
    * `Applicative` is a generalization of `Monad`, allowing expression
    * of effectful computations in a pure functional way.

src/main/scala/catslib/Apply.scala

@@ -23,7 +23,8 @@ import ApplyHelpers._
 import cats._
 import cats.implicits._
 
-/** `Apply` extends the `Functor` type class (which features the familiar `map`
+/**
+ * `Apply` extends the `Functor` type class (which features the familiar `map`
  * function) with a new function `ap`. The `ap` function is similar to `map`
  * in that we are transforming a value in a context (a context being the `F` in `F[A]`;
  * a context can be `Option`, `List` or `Future` for example).
@@ -59,7 +60,8 @@ import cats.implicits._
  */
 object ApplySection extends AnyFlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
-  /** = map =
+  /**
+   * = map =
    *
    * Since `Apply` extends `Functor`, we can use the `map` method from `Functor`:
    */
@@ -75,7 +77,8 @@ object ApplySection extends AnyFlatSpec with Matchers with org.scalaexercises.de
     Apply[Option].map(None)(addTwo) should be(res2)
   }
 
-  /** = compose =
+  /**
+   * = compose =
    *
    * And like functors, `Apply` instances also compose:
    */
@@ -85,7 +88,8 @@ object ApplySection extends AnyFlatSpec with Matchers with org.scalaexercises.de
     listOpt.ap(List(Some(plusOne)))(List(Some(1), None, Some(3))) should be(res0)
   }
 
-  /** = ap =
+  /**
+   * = ap =
    *
    * The `ap` method is a method that `Functor` does not have:
    */
@@ -103,7 +107,8 @@ object ApplySection extends AnyFlatSpec with Matchers with org.scalaexercises.de
     Apply[Option].ap(None)(None) should be(res4)
   }
 
-  /** = ap2, ap3, etc =
+  /**
+   * = ap2, ap3, etc =
    *
    * `Apply` also offers variants of `ap`. The functions `apN` (for `N` between `2` and `22`)
    * accept `N` arguments where `ap` accepts `1`.
@@ -121,28 +126,29 @@ object ApplySection extends AnyFlatSpec with Matchers with org.scalaexercises.de
     Apply[Option].ap3(Some(addArity3))(Some(1), Some(2), Some(3)) should be(res2)
   }
 
-  /** = map2, map3, etc =
+  /**
+   * = map2, map3, etc =
    *
    * Similarly, `mapN` functions are available:
-   *
    */
   def applyMapn(res0: Option[Int], res1: Option[Int]) = {
     Apply[Option].map2(Some(1), Some(2))(addArity2) should be(res0)
 
     Apply[Option].map3(Some(1), Some(2), Some(3))(addArity3) should be(res1)
   }
 
-  /** = tuple2, tuple3, etc =
+  /**
+   * = tuple2, tuple3, etc =
    *
    * Similarly, `tupleN` functions are available:
-   *
    */
   def applyTuplen(res0: Option[(Int, Int)], res1: Option[(Int, Int, Int)]) = {
     Apply[Option].tuple2(Some(1), Some(2)) should be(res0)
     Apply[Option].tuple3(Some(1), Some(2), Some(3)) should be(res1)
   }
 
-  /** = apply builder syntax =
+  /**
+   * = apply builder syntax =
    *
    * In order to use functions `apN`, `mapN` and `tupleN` *infix*,
    * import `cats.implicits._`.

src/main/scala/catslib/CatsLibrary.scala

@@ -16,7 +16,8 @@
 
 package catslib
 
-/** Cats is a library which provides abstractions for functional programming in the Scala programming language.
+/**
+ * Cats is a library which provides abstractions for functional programming in the Scala programming language.
  *
  * @param name cats
  */

src/main/scala/catslib/EitherSection.scala

@@ -55,7 +55,8 @@ object EitherStyleWithAdts {
     parse(s).flatMap(reciprocal).map(stringify)
 }
 
-/** In day-to-day programming, it is fairly common to find ourselves writing functions that
+/**
+ * In day-to-day programming, it is fairly common to find ourselves writing functions that
  * can fail. For instance, querying a service may result in a connection issue, or some
  * unexpected JSON response.
  *
@@ -94,7 +95,8 @@ object EitherStyleWithAdts {
  */
 object EitherSection extends AnyFlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
-  /** More often than not we want to just bias towards one side and call it a day - by convention,
+  /**
+   * More often than not we want to just bias towards one side and call it a day - by convention,
    * the right side is most often chosen.
    */
   def eitherMapRightBias(res0: Either[String, Int], res1: Either[String, Int]) = {
@@ -106,7 +108,8 @@ object EitherSection extends AnyFlatSpec with Matchers with org.scalaexercises.d
     left.map(_ + 1) should be(res1)
   }
 
-  /** Because `Either` is right-biased, it is possible to define a `Monad` instance for it.
+  /**
+   * Because `Either` is right-biased, it is possible to define a `Monad` instance for it.
    *
    * Since we only ever want the computation to continue in the case of `Right` (as captured
    * by the right-bias nature), we fix the left type parameter and leave the right one free.
@@ -125,7 +128,6 @@ object EitherSection extends AnyFlatSpec with Matchers with org.scalaexercises.d
    * }}}
    *
    * So the `flatMap` method is right-biased:
-   *
    */
   def eitherMonad(res0: Either[String, Int], res1: Either[String, Int]) = {
 
@@ -136,7 +138,8 @@ object EitherSection extends AnyFlatSpec with Matchers with org.scalaexercises.d
     left.flatMap(x => Either.right(x + 1)) should be(res1)
   }
 
-  /** = Using `Either` instead of exceptions =
+  /**
+   * = Using `Either` instead of exceptions =
    *
    * As a running example, we will have a series of functions that will parse a string into an integer,
    * take the reciprocal, and then turn the reciprocal into a string.
@@ -178,15 +181,14 @@ object EitherSection extends AnyFlatSpec with Matchers with org.scalaexercises.d
    * }}}
    *
    * Do these calls return a `Right` value?
-   *
    */
   def eitherStyleParse(res0: Boolean, res1: Boolean) = {
     EitherStyle.parse("Not a number").isRight should be(res0)
     EitherStyle.parse("2").isRight should be(res1)
   }
 
-  /** Now, using combinators like `flatMap` and `map`, we can compose our functions together. Will the following incantations return a `Right` value?
-   *
+  /**
+   * Now, using combinators like `flatMap` and `map`, we can compose our functions together. Will the following incantations return a `Right` value?
    */
   def eitherComposition(res0: Boolean, res1: Boolean, res2: Boolean) = {
     import EitherStyle._
@@ -196,7 +198,8 @@ object EitherSection extends AnyFlatSpec with Matchers with org.scalaexercises.d
     magic("Not a number").isRight should be(res2)
   }
 
-  /** With the composite function that we actually care about, we can pass in strings and then pattern
+  /**
+   * With the composite function that we actually care about, we can pass in strings and then pattern
    * match on the exception. Because `Either` is a sealed type (often referred to as an algebraic data type,
    * or ADT), the compiler will complain if we do not check both the `Left` and `Right` case.
    *
@@ -207,7 +210,6 @@ object EitherSection extends AnyFlatSpec with Matchers with org.scalaexercises.d
    * `NumberFormatException` or `IllegalArgumentException`. However, we "know" by inspection of the source
    * that those will be the only exceptions thrown, so it seems strange to have to account for other exceptions.
    * This implies that there is still room to improve.
-   *
    */
   def eitherExceptions(res0: String) = {
     import EitherStyle._
@@ -221,7 +223,8 @@ object EitherSection extends AnyFlatSpec with Matchers with org.scalaexercises.d
     result should be(res0)
   }
 
-  /** Instead of using exceptions as our error value, let's instead enumerate explicitly the things that
+  /**
+   * Instead of using exceptions as our error value, let's instead enumerate explicitly the things that
    * can go wrong in our program.
    *
    * {{{
@@ -249,7 +252,6 @@ object EitherSection extends AnyFlatSpec with Matchers with org.scalaexercises.d
    * exception classes as error values, we use one of the enumerated cases. Now when we pattern
    * match, we get much nicer matching. Moreover, since `Error` is `sealed`, no outside code can
    * add additional subtypes which we might fail to handle.
-   *
    */
   def eitherErrorsAsAdts(res0: String) = {
     import EitherStyleWithAdts._
@@ -262,7 +264,8 @@ object EitherSection extends AnyFlatSpec with Matchers with org.scalaexercises.d
     result should be(res0)
   }
 
-  /** = Either in the small, Either in the large =
+  /**
+   * = Either in the small, Either in the large =
    *
    * Once you start using `Either` for all your error-handling, you may quickly run into an issue where
    * you need to call into two separate modules which give back separate kinds of errors.
@@ -380,7 +383,6 @@ object EitherSection extends AnyFlatSpec with Matchers with org.scalaexercises.d
    * }}}
    *
    * Let's review the `leftMap` and `map` methods:
-   *
    */
   def eitherInTheLarge(
       res0: Either[String, Int],
@@ -395,7 +397,8 @@ object EitherSection extends AnyFlatSpec with Matchers with org.scalaexercises.d
     left.leftMap(_.reverse) should be(res2)
   }
 
-  /** There will inevitably come a time when your nice `Either` code will have to interact with exception-throwing
+  /**
+   * There will inevitably come a time when your nice `Either` code will have to interact with exception-throwing
    * code. Handling such situations is easy enough.
    *
    * {{{
@@ -417,16 +420,15 @@ object EitherSection extends AnyFlatSpec with Matchers with org.scalaexercises.d
    * }}}
    *
    * If you want to catch all (non-fatal) throwables, you can use `catchNonFatal`.
-   *
-   *
    */
   def eitherWithExceptions(res0: Boolean, res1: Boolean) = {
     Either.catchOnly[NumberFormatException]("abc".toInt).isRight should be(res0)
 
     Either.catchNonFatal(1 / 0).isLeft should be(res1)
   }
 
-  /** = Additional syntax =
+  /**
+   * = Additional syntax =
    *
    * For using Either's syntax on arbitrary data types, you can import `cats.implicits._`. This will
    * make possible to use the `asLeft` and `asRight` methods:
@@ -440,7 +442,6 @@ object EitherSection extends AnyFlatSpec with Matchers with org.scalaexercises.d
    * }}}
    *
    * These method promote values to the `Either` data type:
-   *
    */
   def eitherSyntax(res0: Either[String, Int]) = {
     import cats.implicits._

src/main/scala/catslib/EvalSection.scala

@@ -20,7 +20,8 @@ import cats._
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 
-/** Eval is a data type for controlling synchronous evaluation.
+/**
+ * Eval is a data type for controlling synchronous evaluation.
  * Its implementation is designed to provide stack-safety at all times using a technique called trampolining.
  * There are two different factors that play into evaluation: memoization and laziness.
  * Memoized evaluation evaluates an expression only once and then remembers (memoizes) that value.
@@ -34,7 +35,8 @@ import org.scalatest.matchers.should.Matchers
  */
 object EvalSection extends AnyFlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
-  /** = Eval.now =
+  /**
+   * = Eval.now =
    *
    * First of the strategies is eager evaluation, we can construct an Eval eagerly using Eval.now:
    *
@@ -56,7 +58,6 @@ object EvalSection extends AnyFlatSpec with Matchers with org.scalaexercises.def
    * We can run the computation using the given evaluation strategy anytime by using the value method.
    * eager.value
    * // res0: Int = 7
-   *
    */
   def nowEval(resultList: List[Int]) = {
     //given
@@ -69,7 +70,8 @@ object EvalSection extends AnyFlatSpec with Matchers with org.scalaexercises.def
     eagerEval.value shouldBe (resultList: List[Int])
   }
 
-  /** = Eval.later =
+  /**
+   * = Eval.later =
    *
    * If we want lazy evaluation, we can use Eval.later
    * In this case
@@ -94,7 +96,6 @@ object EvalSection extends AnyFlatSpec with Matchers with org.scalaexercises.def
    * Eval.later is different to using a lazy val in a few different ways.
    * First, it allows the runtime to perform garbage collection of the thunk after evaluation, leading to more memory being freed earlier.
    * Secondly, when lazy vals are evaluated, in order to preserve thread-safety, the Scala compiler will lock the whole surrounding class, whereas Eval will only lock itself.
-   *
    */
   def laterEval(resultList: List[Int], counterResult: Int) = {
     //given
@@ -112,7 +113,8 @@ object EvalSection extends AnyFlatSpec with Matchers with org.scalaexercises.def
     counter shouldBe counterResult
   }
 
-  /** = Eval.always =
+  /**
+   * = Eval.always =
    *
    * If we want lazy evaluation, but without memoization akin to Function0, we can use Eval.always
    * Here we can see, that the expression is evaluated every time we call .value.
@@ -125,7 +127,6 @@ object EvalSection extends AnyFlatSpec with Matchers with org.scalaexercises.def
    * //Always evaluated
    * alwaysEval.eval
    * }}}
-   *
    */
   def alwaysEval(resultList: List[Int], counterAfterListEval: Int, latestCounter: Int) = {
     //given
@@ -144,12 +145,12 @@ object EvalSection extends AnyFlatSpec with Matchers with org.scalaexercises.def
     counter shouldBe latestCounter
   }
 
-  /** = Eval.defer =
+  /**
+   * = Eval.defer =
    *
    * Defer a computation which produces an Eval[A] value
    * This is useful when you want to delay execution of an expression which produces an Eval[A] value. Like .flatMap, it is stack-safe.
    * Because Eval guarantees stack-safety, we can chain a lot of computations together using flatMap without fear of blowing up the stack.
-   *
    */
   def deferEval(resultList: List[Int]) = {
     //given