WIP: Scala 3 Overhaul

build.sbt

@@ -4,7 +4,7 @@ ThisBuild / name               := "scala-with-cats"
 ThisBuild / organization       := "com.scalawithcats"
 ThisBuild / version            := "0.0.1"
 
-ThisBuild / scalaVersion       := "2.13.8"
+ThisBuild / scalaVersion       := "3.2.2"
 
 ThisBuild / useSuperShell      := false
 Global    / logLevel           := Level.Warn
@@ -14,11 +14,14 @@ enablePlugins(MdocPlugin)
 mdocIn  := sourceDirectory.value / "pages"
 mdocOut := target.value          / "pages"
 
-val catsVersion  = "2.7.0"
+scalacOptions ++= Seq(
+  "-explain", // Better diagnostics
+  "-Ykind-projector:underscores" // In-lieu of kind-projector
+)
 
-libraryDependencies ++= Seq("org.typelevel" %% "cats-core" % catsVersion)
+val catsVersion  = "2.9.0"
 
-addCompilerPlugin("org.typelevel" % "kind-projector" % "0.13.2" cross CrossVersion.full)
+libraryDependencies ++= Seq("org.typelevel" %% "cats-core" % catsVersion)
 
 mdocVariables := Map(
   "SCALA_VERSION" -> scalaVersion.value,

package.json

@@ -10,12 +10,12 @@
   "devDependencies": {
     "bootstrap": "^3.4.1",
     "coffeeify": "1.0.0",
+    "coffeescript": "^2.5.1",
     "jquery": "3.5.0",
-    "uglifyify": "2.6.0",
     "lessc": "^1.0.2",
-    "underscore": "1.7.0",
     "pandoc-filter": "0.1.6",
-    "coffeescript": "^2.5.1"
+    "uglifyify": "2.6.0",
+    "underscore": "1.7.0"
   },
   "author": "Noel Welsh and Dave Gurnell"
 }

project/Pandoc.scala

@@ -118,7 +118,7 @@ object Pandoc {
         "--table-of-contents",
         "--highlight-style tango",
         "--standalone",
-        "--self-contained",
+        "--embed-resources",
       ),
       extras,
       metadata,

project/build.properties

@@ -1 +1 @@
-sbt.version=1.6.1
+sbt.version=1.8.2

project/plugins.sbt

@@ -1,2 +1,2 @@
-addSbtPlugin("org.scalameta" % "sbt-mdoc" % "2.3.0" )
+addSbtPlugin("org.scalameta" % "sbt-mdoc" % "2.3.7" )
 // addSbtPlugin("io.github.davidgregory084" % "sbt-tpolecat" % "0.1.10")

src/pages/adt/scala.md

@@ -20,10 +20,8 @@ Not everyone makes their case classes `final`, but they should. A non-`final` ca
 A logical or (a sum type) is represented by an `enum`. For the sum type `A` is a `B` **or** `C` the Scala 3 representation is
 
 ```scala
-enum A {
-  case B
-  case C
-}
+enum A:
+  case B, C
 ```
 
 There are a few wrinkles to be aware of. 
@@ -37,13 +35,12 @@ If we have a sum of products, such as:
 the representation is
 
 ```scala
-enum A {
+enum A:
   case B(d: D, e: E)
   case C(f: F, g: G)
-}
 ```
 
-In other words you can't write `final case class` inside an `enum`. You also can't nest `enum` inside `enum`. Nexted logical ors  can be rewritten into a single logical or containing only logical ands (known as disjunctive normal form) so this is not a limitation in practice. However the Scala 2 representation is still available in Scala 3 should you want more expressivity.
+In other words you can't write `final case class` inside an `enum`. You also can't nest `enum` inside `enum`. Nested logical ors can be rewritten into a single logical or containing only logical ands (known as disjunctive normal form) so this is not a limitation in practice. However the Scala 2 representation is still available in Scala 3 should you want more expressivity.
 
 
 ### Algebraic Data Types in Scala 2

src/pages/applicatives/applicative.md

@@ -24,16 +24,14 @@ introduced in Chapter [@sec:monads].
 Here's a simplified definition in code:
 
 ```scala
-trait Apply[F[_]] extends Semigroupal[F] with Functor[F] {
+trait Apply[F[_]] extends Semigroupal[F] with Functor[F]:
   def ap[A, B](ff: F[A => B])(fa: F[A]): F[B]
 
   def product[A, B](fa: F[A], fb: F[B]): F[(A, B)] =
     ap(map(fa)(a => (b: B) => (a, b)))(fb)
-}
 
-trait Applicative[F[_]] extends Apply[F] {
+trait Applicative[F[_]] extends Apply[F]:
   def pure[A](a: A): F[A]
-}
 ```
 
 Breaking this down, the `ap` method applies a parameter `fa`

src/pages/applicatives/examples.md

@@ -12,9 +12,9 @@ provide parallel as opposed to sequential execution:
 
 ```scala mdoc:silent
 import cats.Semigroupal
-import cats.instances.future._ // for Semigroupal
-import scala.concurrent._
-import scala.concurrent.duration._
+import cats.instances.future.* // for Semigroupal
+import scala.concurrent.*
+import scala.concurrent.duration.*
 import scala.concurrent.ExecutionContext.Implicits.global
 
 val futurePair = Semigroupal[Future].
@@ -31,7 +31,7 @@ by the time we call `product`.
 We can use apply syntax to zip fixed numbers of `Futures`:
 
 ```scala mdoc:silent
-import cats.syntax.apply._ // for mapN
+import cats.syntax.apply.* // for mapN
 
 case class Cat(
   name: String,
@@ -59,7 +59,7 @@ but we actually get the cartesian product of their elements:
 
 ```scala mdoc:silent
 import cats.Semigroupal
-import cats.instances.list._ // for Semigroupal
+import cats.instances.list.* // for Semigroupal
 ```
 
 ```scala mdoc
@@ -81,7 +81,7 @@ we find that `product` implements
 the same fail-fast behaviour as `flatMap`:
 
 ```scala mdoc:silent
-import cats.instances.either._ // for Semigroupal
+import cats.instances.either.* // for Semigroupal
 
 type ErrorOr[A] = Either[Vector[String], A]
 ```
@@ -105,8 +105,8 @@ If we have a monad we can implement `product` as follows.
 
 ```scala mdoc:silent
 import cats.Monad
-import cats.syntax.functor._ // for map
-import cats.syntax.flatMap._ // for flatmap
+import cats.syntax.functor.* // for map
+import cats.syntax.flatMap.* // for flatmap
 
 def product[F[_]: Monad, A, B](fa: F[A], fb: F[B]): F[(A,B)] =
   fa.flatMap(a => 
@@ -178,8 +178,8 @@ the definition of `product` in terms of
 import cats.Monad
 ```
 ```scala mdoc:silent
-import cats.syntax.functor._ // for map
-import cats.syntax.flatMap._ // for flatMap
+import cats.syntax.functor.* // for map
+import cats.syntax.flatMap.* // for flatMap
 
 def product[F[_]: Monad, A, B](x: F[A], y: F[B]): F[(A, B)] =
   x.flatMap(a => y.map(b => (a, b)))
@@ -189,8 +189,8 @@ This code is equivalent to a for comprehension:
 
 ```scala mdoc:invisible:reset-object
 import cats.Monad
-import cats.syntax.flatMap._ // for flatMap
-import cats.syntax.functor._ // for map
+import cats.syntax.flatMap.* // for flatMap
+import cats.syntax.functor.* // for map
 ```
 ```scala mdoc:silent
 def product[F[_]: Monad, A, B](x: F[A], y: F[B]): F[(A, B)] =
@@ -204,7 +204,7 @@ The semantics of `flatMap` are what give rise
 to the behaviour for `List` and `Either`:
 
 ```scala mdoc:silent
-import cats.instances.list._ // for Semigroupal
+import cats.instances.list.* // for Semigroupal
 ```
 
 ```scala mdoc

src/pages/applicatives/index.md

@@ -19,7 +19,7 @@ fails on the first call to `parseInt`
 and doesn't go any further:
 
 ```scala mdoc:silent
-import cats.syntax.either._ // for catchOnly
+import cats.syntax.either.* // for catchOnly
 
 def parseInt(str: String): Either[String, Int] =
   Either.catchOnly[NumberFormatException](str.toInt).

src/pages/applicatives/parallel.md

@@ -17,7 +17,7 @@ stops at the first error.
 
 ```scala mdoc:silent
 import cats.Semigroupal
-import cats.instances.either._ // for Semigroupal
+import cats.instances.either.* // for Semigroupal
 
 type ErrorOr[A] = Either[Vector[String], A]
 val error1: ErrorOr[Int] = Left(Vector("Error 1"))
@@ -33,8 +33,8 @@ using `tupled`
 as a short-cut.
 
 ```scala mdoc:silent
-import cats.syntax.apply._ // for tupled
-import cats.instances.vector._ // for Semigroup on Vector
+import cats.syntax.apply.* // for tupled
+import cats.instances.vector.* // for Semigroup on Vector
 ```
 ```scala mdoc
 (error1, error2).tupled
@@ -45,7 +45,7 @@ we simply replace `tupled` with its "parallel" version
 called `parTupled`.
 
 ```scala mdoc:silent
-import cats.syntax.parallel._ // for parTupled
+import cats.syntax.parallel.* // for parTupled
 ```
 ```scala mdoc
 (error1, error2).parTupled
@@ -57,7 +57,7 @@ Any type that has a `Semigroup` instance will work.
 For example, here we use `List` instead.
 
 ```scala mdoc:silent
-import cats.instances.list._ // for Semigroup on List
+import cats.instances.list.* // for Semigroup on List
 
 type ErrorOrList[A] = Either[List[String], A]
 val errStr1: ErrorOrList[Int] = Left(List("error 1"))
@@ -88,13 +88,12 @@ Let's dig into how `Parallel` works.
 The definition below is the core of `Parallel`.
 
 ```scala
-trait Parallel[M[_]] {
+trait Parallel[M[_]]:
   type F[_]
 
   def applicative: Applicative[F]
   def monad: Monad[M]
   def parallel: ~>[M, F]
-}
 ```
 
 This tells us if there is a `Parallel` instance for some type constructor `M` then:
@@ -115,13 +114,11 @@ by defining a `FunctionK` that converts an `Option` to a `List`.
 ```scala mdoc:silent
 import cats.arrow.FunctionK
 
-object optionToList extends FunctionK[Option, List] {
+object optionToList extends FunctionK[Option, List]:
   def apply[A](fa: Option[A]): List[A] =
-    fa match {
+    fa match
       case None    => List.empty[A]
       case Some(a) => List(a)
-    }
-}
 ```
 ```scala mdoc
 optionToList(Some(1))
@@ -160,7 +157,7 @@ insted of creating the cartesian product.
 We can see by writing a little bit of code.
 
 ```scala mdoc:silent
-import cats.instances.list._
+import cats.instances.list.*
 ```
 ```scala mdoc
 (List(1, 2), List(3, 4)).tupled

src/pages/applicatives/semigroupal.md

@@ -7,9 +7,8 @@ a `Semigroupal[F]` allows us to combine them to form an `F[(A, B)]`.
 Its definition in Cats is:
 
 ```scala
-trait Semigroupal[F[_]] {
+trait Semigroupal[F[_]]:
   def product[A, B](fa: F[A], fb: F[B]): F[(A, B)]
-}
 ```
 
 As we discussed at the beginning of this chapter,
@@ -34,7 +33,7 @@ Let's join some `Options` as an example:
 
 ```scala mdoc:silent:reset-object
 import cats.Semigroupal
-import cats.instances.option._ // for Semigroupal
+import cats.instances.option.* // for Semigroupal
 ```
 
 ```scala mdoc
@@ -59,7 +58,7 @@ For example, the methods `tuple2` through `tuple22`
 generalise `product` to different arities:
 
 ```scala mdoc:silent
-import cats.instances.option._ // for Semigroupal
+import cats.instances.option.* // for Semigroupal
 ```
 
 ```scala mdoc
@@ -98,8 +97,8 @@ We import the syntax from [`cats.syntax.apply`][cats.syntax.apply].
 Here's an example:
 
 ```scala mdoc:silent
-import cats.instances.option._ // for Semigroupal
-import cats.syntax.apply._     // for tupled and mapN
+import cats.instances.option.* // for Semigroupal
+import cats.syntax.apply.*     // for tupled and mapN
 ```
 
 The `tupled` method is implicitly added to the tuple of `Options`.
@@ -167,11 +166,11 @@ Here's an example:
 
 ```scala mdoc:silent:reset-object
 import cats.Monoid
-import cats.instances.int._        // for Monoid
-import cats.instances.invariant._  // for Semigroupal
-import cats.instances.list._       // for Monoid
-import cats.instances.string._     // for Monoid
-import cats.syntax.apply._         // for imapN
+import cats.instances.int.*        // for Monoid
+import cats.instances.invariant.*  // for Semigroupal
+import cats.instances.list.*       // for Monoid
+import cats.instances.string.*     // for Monoid
+import cats.syntax.apply.*         // for imapN
 
 final case class Cat(
   name: String,
@@ -185,7 +184,7 @@ val tupleToCat: (String, Int, List[String]) => Cat =
 val catToTuple: Cat => (String, Int, List[String]) =
   cat => (cat.name, cat.yearOfBirth, cat.favoriteFoods)
 
-implicit val catMonoid: Monoid[Cat] = (
+given catMonoid: Monoid[Cat] = (
   Monoid[String],
   Monoid[Int],
   Monoid[List[String]]
@@ -196,7 +195,7 @@ Our `Monoid` allows us to create "empty" `Cats`,
 and add `Cats` together using the syntax from Chapter [@sec:monoids]:
 
 ```scala mdoc:silent
-import cats.syntax.semigroup._ // for |+|
+import cats.syntax.semigroup.* // for |+|
 
 val garfield   = Cat("Garfield", 1978, List("Lasagne"))
 val heathcliff = Cat("Heathcliff", 1988, List("Junk Food"))