Update scalafmt-core to 3.0.0

Author: 47erbot

.scalafmt.conf

@@ -1,4 +1,4 @@
-version=2.7.5
+version=3.0.0
 style = defaultWithAlign
 maxColumn = 100
 
@@ -15,9 +15,9 @@ align {
   openParenDefnSite = false
 }
 
-docstrings = JavaDoc
+docstrings.style = Asterisk
 
 rewrite {
   rules = [SortImports, RedundantBraces]
   redundantBraces.maxLines = 1
-}
+}

build.sbt

@@ -1,11 +1,11 @@
 import com.jsuereth.sbtpgp.PgpKeys.publishSigned
 
-ThisBuild / organization := "org.scala-exercises"
+ThisBuild / organization       := "org.scala-exercises"
 ThisBuild / githubOrganization := "47degrees"
-ThisBuild / scalaVersion := "2.13.3"
+ThisBuild / scalaVersion       := "2.13.3"
 
 // 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/scalatutorial/ScalaTutorial.scala

@@ -21,9 +21,11 @@ import org.scalaexercises.definitions.Library
 import sections._
 
 /**
- * Quickly learn Scala through an interactive tutorial based on the first two courses of the Scala MOOCs.
+ * Quickly learn Scala through an interactive tutorial based on the first two courses of the Scala
+ * MOOCs.
  *
- * @param name scala_tutorial
+ * @param name
+ *   scala_tutorial
  */
 object ScalaTutorial extends Library {
   val owner          = "scala-exercises"

src/main/scala/scalatutorial/sections/ClassesVsCaseClasses.scala

@@ -19,20 +19,19 @@ package scalatutorial.sections
 import scalatutorial.utils.{BankAccount, Note}
 
 /**
- * @param name classes_vs_case_classes
+ * @param name
+ *   classes_vs_case_classes
  */
 object ClassesVsCaseClasses extends ScalaTutorialSection {
 
   /**
-   * In the previous sections we have seen how case classes could be
-   * used to achieve information aggregation, and also how classes
-   * could be used to achieve data abstraction or to define stateful
-   * objects.
+   * In the previous sections we have seen how case classes could be used to achieve information
+   * aggregation, and also how classes could be used to achieve data abstraction or to define
+   * stateful objects.
    *
-   * What are the relationship between classes and case classes? How
-   * do they differ?
+   * What are the relationship between classes and case classes? How do they differ?
    *
-   * = Creation and Manipulation =
+   * =Creation and Manipulation=
    *
    * Remember the class definition of `BankAccount`:
    *
@@ -69,21 +68,20 @@ object ClassesVsCaseClasses extends ScalaTutorialSection {
   }
 
   /**
-   * We see that creating a class instance requires the keyword `new`, whereas
-   * this is not required for case classes.
+   * We see that creating a class instance requires the keyword `new`, whereas this is not required
+   * for case classes.
    *
-   * Also, we see that the case class constructor parameters are promoted to
-   * members, whereas this is not true for regular classes: the parameters
-   * will remain private.
+   * Also, we see that the case class constructor parameters are promoted to members, whereas this
+   * is not true for regular classes: the parameters will remain private.
    *
    * {{{
-   *    class MyClass(x: Int) { def doubledX = x * 2 }
-   *    val myInstance = new MyClass(5)
-   *    myInstance.doubledX // returns  10
-   *    myInstance.x        // error: value x is not a member of MyClass
+   *     class MyClass(x: Int) { def doubledX = x * 2 }
+   *     val myInstance = new MyClass(5)
+   *     myInstance.doubledX // returns  10
+   *     myInstance.x        // error: value x is not a member of MyClass
    * }}}
    *
-   * = Equality =
+   * =Equality=
    */
   def equality(res0: Boolean, res1: Boolean): Unit = {
     val aliceAccount = new BankAccount
@@ -98,18 +96,17 @@ object ClassesVsCaseClasses extends ScalaTutorialSection {
   }
 
   /**
-   * In the above example, the same definitions of bank accounts lead to different
-   * values, whereas the same definitions of notes lead to equal values.
+   * In the above example, the same definitions of bank accounts lead to different values, whereas
+   * the same definitions of notes lead to equal values.
    *
    * As we have seen in the previous sections, stateful classes introduce a notion of ''identity''
-   * that does not exist in case classes. Indeed, the value of `BankAccount` can change over
-   * time whereas the value of a `Note` is immutable.
+   * that does not exist in case classes. Indeed, the value of `BankAccount` can change over time
+   * whereas the value of a `Note` is immutable.
    *
-   * In Scala, by default, comparing objects will compare their identity, but in the
-   * case of case class instances, the equality is redefined to compare the values of
-   * the aggregated information.
+   * In Scala, by default, comparing objects will compare their identity, but in the case of case
+   * class instances, the equality is redefined to compare the values of the aggregated information.
    *
-   * = Pattern Matching =
+   * =Pattern Matching=
    *
    * We saw how pattern matching can be used to extract information from a case class instance:
    *
@@ -121,24 +118,23 @@ object ClassesVsCaseClasses extends ScalaTutorialSection {
    *
    * By default, pattern matching does not work with regular classes.
    *
-   * = Extensibility =
+   * =Extensibility=
    *
-   * A class can extend another class, whereas a case class can not extend
-   * another case class (because it would not be possible to correctly
-   * implement their equality).
+   * A class can extend another class, whereas a case class can not extend another case class
+   * (because it would not be possible to correctly implement their equality).
    *
-   * = Case Classes Encoding =
+   * =Case Classes Encoding=
    *
    * We saw the main differences between classes and case classes.
    *
-   * It turns out that case classes are just a special case of classes,
-   * whose purpose is to aggregate several values into a single value.
+   * It turns out that case classes are just a special case of classes, whose purpose is to
+   * aggregate several values into a single value.
    *
-   * The Scala language provides explicit support for this use case
-   * because it is very common in practice.
+   * The Scala language provides explicit support for this use case because it is very common in
+   * practice.
    *
-   * So, when we define a case class, the Scala compiler defines a class
-   * enhanced with some more methods and a companion object.
+   * So, when we define a case class, the Scala compiler defines a class enhanced with some more
+   * methods and a companion object.
    *
    * For instance, the following case class definition:
    *

src/main/scala/scalatutorial/sections/DefinitionsAndEvaluation.scala

@@ -17,22 +17,22 @@
 package scalatutorial.sections
 
 /**
- * @param name definitions_and_evaluation
+ * @param name
+ *   definitions_and_evaluation
  */
 object DefinitionsAndEvaluation extends ScalaTutorialSection {
 
   /**
-   * = Naming Things =
+   * =Naming Things=
    *
-   * Consider the following program that computes the area of a disc
-   * whose radius is `10`:
+   * Consider the following program that computes the area of a disc whose radius is `10`:
    *
    * {{{
    *   3.14159 * 10 * 10
    * }}}
    *
-   * To make complex expressions more readable we can give meaningful names to
-   * intermediate expressions:
+   * To make complex expressions more readable we can give meaningful names to intermediate
+   * expressions:
    *
    * {{{
    *   val radius = 10
@@ -41,14 +41,14 @@ object DefinitionsAndEvaluation extends ScalaTutorialSection {
    *   pi * radius * radius
    * }}}
    *
-   * Besides making the last expression more readable it also allows us to
-   * not repeat the actual value of the radius.
+   * Besides making the last expression more readable it also allows us to not repeat the actual
+   * value of the radius.
    *
-   * = Evaluation =
+   * =Evaluation=
    *
    * A name is evaluated by replacing it with the right hand side of its definition
    *
-   * == Example ==
+   * ==Example==
    *
    * Here are the evaluation steps of the above expression:
    *
@@ -61,7 +61,7 @@ object DefinitionsAndEvaluation extends ScalaTutorialSection {
    *   314.159
    * }}}
    *
-   * = Methods =
+   * =Methods=
    *
    * Definitions can have parameters. For instance:
    */
@@ -83,15 +83,15 @@ object DefinitionsAndEvaluation extends ScalaTutorialSection {
   }
 
   /**
-   * = Multiple Parameters =
+   * =Multiple Parameters=
    *
    * Separate several parameters with commas:
    *
    * {{{
    *   def sumOfSquares(x: Double, y: Double) = square(x) + square(y)
    * }}}
    *
-   * = Parameters and Return Types =
+   * =Parameters and Return Types=
    *
    * Function parameters come with their type, which is given after a colon
    *
@@ -101,12 +101,12 @@ object DefinitionsAndEvaluation extends ScalaTutorialSection {
    *
    * If a return type is given, it follows the parameter list.
    *
-   * = Val vs Def =
+   * =Val vs Def=
    *
    * The right hand side of a `def` definition is evaluated on each use.
    *
-   * The right hand side of a `val` definition is evaluated at the point of the definition
-   * itself. Afterwards, the name refers to the value.
+   * The right hand side of a `val` definition is evaluated at the point of the definition itself.
+   * Afterwards, the name refers to the value.
    *
    * {{{
    *   val x = 2
@@ -115,16 +115,15 @@ object DefinitionsAndEvaluation extends ScalaTutorialSection {
    *
    * For instance, `y` above refers to `4`, not `square(2)`.
    *
-   * = Evaluation of Function Applications =
+   * =Evaluation of Function Applications=
    *
-   * Applications of parametrized functions are evaluated in a similar way as
-   * operators:
+   * Applications of parametrized functions are evaluated in a similar way as operators:
    *
-   *  1. Evaluate all function arguments, from left to right
-   *  1. Replace the function application by the function's right-hand side, and, at the same time
-   *  1. Replace the formal parameters of the function by the actual arguments.
+   *   1. Evaluate all function arguments, from left to right
+   *   1. Replace the function application by the function's right-hand side, and, at the same time
+   *   1. Replace the formal parameters of the function by the actual arguments.
    *
-   * == Example ==
+   * ==Example==
    *
    * {{{
    *   sumOfSquares(3, 2+2)
@@ -137,19 +136,19 @@ object DefinitionsAndEvaluation extends ScalaTutorialSection {
    *   25
    * }}}
    *
-   * = The substitution model =
+   * =The substitution model=
    *
    * This scheme of expression evaluation is called the ''substitution model''.
    *
-   * The idea underlying this model is that all evaluation does is ''reduce
-   * an expression to a value''.
+   * The idea underlying this model is that all evaluation does is ''reduce an expression to a
+   * value''.
    *
    * It can be applied to all expressions, as long as they have no side effects.
    *
-   * The substitution model is formalized in the λ-calculus, which gives
-   * a foundation for functional programming.
+   * The substitution model is formalized in the λ-calculus, which gives a foundation for functional
+   * programming.
    *
-   * = Termination =
+   * =Termination=
    *
    * Does every expression reduce to a value (in a finite number of steps)?
    *
@@ -161,10 +160,10 @@ object DefinitionsAndEvaluation extends ScalaTutorialSection {
    *   loop
    * }}}
    *
-   * = Value Definitions and Termination =
+   * =Value Definitions and Termination=
    *
-   * The difference between `val` and `def` becomes apparent when the right
-   * hand side does not terminate. Given
+   * The difference between `val` and `def` becomes apparent when the right hand side does not
+   * terminate. Given
    *
    * {{{
    *   def loop: Int = loop
@@ -184,10 +183,9 @@ object DefinitionsAndEvaluation extends ScalaTutorialSection {
    *
    * will lead to an infinite loop.
    *
-   * = Changing the evaluation strategy =
+   * =Changing the evaluation strategy=
    *
-   * The interpreter reduces function arguments to values before rewriting the
-   * function application.
+   * The interpreter reduces function arguments to values before rewriting the function application.
    *
    * One could alternatively apply the function to unreduced arguments.
    *
@@ -204,30 +202,27 @@ object DefinitionsAndEvaluation extends ScalaTutorialSection {
    *   25
    * }}}
    *
-   * = Call-by-name and call-by-value =
+   * =Call-by-name and call-by-value=
    *
-   * The first evaluation strategy is known as ''call-by-value'',
-   * the second is known as ''call-by-name''.
+   * The first evaluation strategy is known as ''call-by-value'', the second is known as
+   * ''call-by-name''.
    *
-   * Both strategies reduce to the same final values
-   * as long as
+   * Both strategies reduce to the same final values as long as
    *
-   *  - the reduced expression consists of pure functions, and
-   *  - both evaluations terminate.
+   *   - the reduced expression consists of pure functions, and
+   *   - both evaluations terminate.
    *
-   * Call-by-value has the advantage that it evaluates every function argument
-   * only once.
+   * Call-by-value has the advantage that it evaluates every function argument only once.
    *
-   * Call-by-name has the advantage that a function argument is not evaluated if the
-   * corresponding parameter is unused in the evaluation of the function body.
+   * Call-by-name has the advantage that a function argument is not evaluated if the corresponding
+   * parameter is unused in the evaluation of the function body.
    *
    * Scala normally uses call-by-value.
    *
-   * = Exercise =
+   * =Exercise=
    *
-   * Complete the following definition of the `triangleArea` function,
-   * which takes a triangle base and height as parameters and returns
-   * its area:
+   * Complete the following definition of the `triangleArea` function, which takes a triangle base
+   * and height as parameters and returns its area:
    */
   def triangleAreaExercise(res0: Double, res1: Double): Unit = {
     def triangleArea(base: Double, height: Double): Double =