Scala 3 Braceless Syntax cont.

Author: fabianhjr

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/parallel.md

@@ -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:

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,

src/pages/case-studies/crdt/abstraction.md

@@ -27,29 +27,25 @@ represent the key and value types of the map abstraction.
 ```scala mdoc:reset-object:invisible
 import cats.kernel.CommutativeMonoid
 
-trait BoundedSemiLattice[A] extends CommutativeMonoid[A] {
+trait BoundedSemiLattice[A] extends CommutativeMonoid[A]:
   def combine(a1: A, a2: A): A
   def empty: A
-}
 
-object BoundedSemiLattice {
-  given intInstance: BoundedSemiLattice[Int] with
-    def combine(a1: Int, a2: Int): Int =
-      a1 max a2
+given intInstance: BoundedSemiLattice[Int] with
+  def combine(a1: Int, a2: Int): Int =
+    a1 max a2
 
-    val empty: Int =
-      0
+  val empty: Int = 0
 
-  given setInstance[A]: BoundedSemiLattice[Set[A]] with
-    def combine(a1: Set[A], a2: Set[A]): Set[A] =
-      a1 union a2
+given setInstance[A]: BoundedSemiLattice[Set[A]] with
+  def combine(a1: Set[A], a2: Set[A]): Set[A] =
+    a1 union a2
 
-    val empty: Set[A] =
-      Set.empty[A]
-}
+  val empty: Set[A] =
+    Set.empty[A]
 ```
 ```scala mdoc:silent
-trait GCounter[F[_,_],K, V] {
+trait GCounter[F[_,_],K, V]:
   def increment(f: F[K, V])(k: K, v: V)
         (using m: CommutativeMonoid[V]): F[K, V]
 
@@ -58,13 +54,11 @@ trait GCounter[F[_,_],K, V] {
 
   def total(f: F[K, V])
         (using m: CommutativeMonoid[V]): V
-}
 
-object GCounter {
+object GCounter:
   def apply[F[_,_], K, V]
         (using counter: GCounter[F, K, V]) =
     counter
-}
 ```
 
 Try defining an instance of this type class for `Map`.
@@ -114,7 +108,7 @@ val counter = GCounter[Map, String, Int]
 
 ```scala mdoc
 val merged = counter.merge(g1, g2)
-val total  = counter.total(merged)
+val total  = counter.total(merged)(using intInstance)
 ```
 
 The implementation strategy
@@ -133,7 +127,7 @@ for any type that has a `KeyValueStore` instance.
 Here's the code for such a type class:
 
 ```scala mdoc:silent
-trait KeyValueStore[F[_,_]] {
+trait KeyValueStore[F[_,_]]:
   def put[K, V](f: F[K, V])(k: K, v: V): F[K, V]
 
   def get[K, V](f: F[K, V])(k: K): Option[V]
@@ -142,7 +136,6 @@ trait KeyValueStore[F[_,_]] {
     get(f)(k).getOrElse(default)
 
   def values[K, V](f: F[K, V]): List[V]
-}
 ```
 
 Implement your own instance for `Map`.
@@ -197,9 +190,7 @@ instances of `KeyValueStore` and `CommutativeMonoid`
 using an `implicit def`:
 
 ```scala mdoc:silent
-implicit def gcounterInstance[F[_,_], K, V]
-    (using kvs: KeyValueStore[F], km: CommutativeMonoid[F[K, V]]): GCounter[F, K, V] =
-  new GCounter[F, K, V] {
+given gcounterInstance[F[_,_], K, V](using kvs: KeyValueStore[F], km: CommutativeMonoid[F[K, V]]): GCounter[F, K, V] with
     def increment(f: F[K, V])(key: K, value: V)
           (using m: CommutativeMonoid[V]): F[K, V] = {
       val total = f.getOrElse(key, m.empty) |+| value
@@ -212,7 +203,6 @@ implicit def gcounterInstance[F[_,_], K, V]
 
     def total(f: F[K, V])(using m: CommutativeMonoid[V]): V =
       f.values.combineAll
-  }
 ```
 
 The complete code for this case study is quite long,

src/pages/case-studies/crdt/g-counter.md

@@ -100,7 +100,7 @@ We can implement a GCounter with the following interface,
 where we represent machine IDs as `Strings`.
 
 ```scala mdoc:reset-object:silent
-final case class GCounter(counters: Map[String, Int]) {
+final case class GCounter(counters: Map[String, Int]):
   def increment(machine: String, amount: Int) =
     ???
 
@@ -109,7 +109,6 @@ final case class GCounter(counters: Map[String, Int]) {
 
   def total: Int =
     ???
-}
 ```
 
 Finish the implementation!
@@ -119,7 +118,7 @@ Hopefully the description above was clear enough that
 you can get to an implementation like the one below.
 
 ```scala mdoc:silent:reset-object
-final case class GCounter(counters: Map[String, Int]) {
+final case class GCounter(counters: Map[String, Int]):
   def increment(machine: String, amount: Int) = {
     val value = amount + counters.getOrElse(machine, 0)
     GCounter(counters + (machine -> value))
@@ -131,8 +130,6 @@ final case class GCounter(counters: Map[String, Int]) {
         k -> (v max that.counters.getOrElse(k, 0))
     })
 
-  def total: Int =
-    counters.values.sum
-}
+  def total: Int = counters.values.sum
 ```
 </div>

src/pages/case-studies/crdt/generalisation.md

@@ -113,10 +113,9 @@ our own `BoundedSemiLattice` type class.
 ```scala mdoc:silent
 import cats.kernel.CommutativeMonoid
 
-trait BoundedSemiLattice[A] extends CommutativeMonoid[A] {
+trait BoundedSemiLattice[A] extends CommutativeMonoid[A]:
   def combine(a1: A, a2: A): A
   def empty: A
-}
 ```
 
 In the implementation above,
@@ -146,28 +145,26 @@ import cats.kernel.CommutativeMonoid
 ```
 
 ```scala mdoc:silent
-object wrapper {
-  trait BoundedSemiLattice[A] extends CommutativeMonoid[A] {
+object wrapper:
+  trait BoundedSemiLattice[A] extends CommutativeMonoid[A]:
     def combine(a1: A, a2: A): A
     def empty: A
-  }
 
-  object BoundedSemiLattice {
-    given intInstance: BoundedSemiLattice[Int] with
-      def combine(a1: Int, a2: Int): Int =
-        a1 max a2
+  given intInstance: BoundedSemiLattice[Int] with
+    def combine(a1: Int, a2: Int): Int =
+      a1 max a2
 
-      val empty: Int =
-        0
+    val empty: Int =
+      0
 
-    given setInstance[A]: BoundedSemiLattice[Set[A]] with
-      def combine(a1: Set[A], a2: Set[A]): Set[A] =
-        a1 union a2
+  given setInstance[A]: BoundedSemiLattice[Set[A]] with
+    def combine(a1: Set[A], a2: Set[A]): Set[A] =
+      a1 union a2
 
-      val empty: Set[A] =
-        Set.empty[A]
-  }
-}; import wrapper.*
+    val empty: Set[A] =
+      Set.empty[A]
+
+import wrapper.*
 ```
 </div>
 
@@ -197,7 +194,7 @@ import cats.instances.map.*    // for Monoid
 import cats.syntax.semigroup.* // for |+|
 import cats.syntax.foldable.*  // for combineAll
 
-final case class GCounter[A](counters: Map[String,A]) {
+final case class GCounter[A](counters: Map[String,A]):
   def increment(machine: String, amount: A)
         (using m: CommutativeMonoid[A]): GCounter[A] = {
     val value = amount |+| counters.getOrElse(machine, m.empty)
@@ -210,7 +207,6 @@ final case class GCounter[A](counters: Map[String,A]) {
 
   def total(using m: CommutativeMonoid[A]): A =
     this.counters.values.toList.combineAll
-}
 ```
 </div>
 

src/pages/case-studies/parser/applicative.md

@@ -143,13 +143,12 @@ Let's implement an instance of Scalaz's `Applicative` type class for our `Parser
 Define a typeclass instance of `Applicative` for `Parser`. You must implement the following trait:
 
 ~~~ scala
-Applicative[Parser] {
+Applicative[Parser] with
   def point[A](a: => A): Parser[A] =
     ???
 
   def ap[A, B](fa: => Parser[A])(f: => Parser[A => B]): Parser[B] =
     ???
-}
 ~~~
 
 Hints:
@@ -166,25 +165,24 @@ The usual place to define typeclass instances is as implicit elements on the com
 val identity: Parser[Unit] =
   Parser { input => Success(Unit, input) }
 
-implicit object applicativeInstance extends Applicative[Parser] {
+given applicativeInstance: Applicative[Parser] with
   def point[A](a: => A): Parser[A] =
     identity map (_ => a)
 
   def ap[A, B](fa: => Parser[A])(f: => Parser[A => B]): Parser[B] =
     Parser { input =>
-      f.parse(input) match {
+      f.parse(input) match
         case fail @ Failure(_) =>
           fail
         case Success(aToB, remainder) =>
-          fa.parse(remainder) match {
+          fa.parse(remainder) match
             case fail @ Failure(_) =>
               fail
             case Success(a, remainder1) =>
               Success(aToB(a), remainder1)
-          }
-      }
+          end match
+      end match
     }
-}
 ~~~
 
 Checkout the `parser-applicative` tag to see the full code and tests.

src/pages/case-studies/parser/error-handling.md

@@ -129,11 +129,8 @@ Implement a parser for digits using the regular expression `"[0-9]"` to match a
 ~~~ scala
 package underscore.parser
 
-object NumericParser {
-
+object NumericParser:
   val digits = Parser.regex("[0-9]").+
-
-}
 ~~~
 </div>
 
@@ -184,14 +181,11 @@ If `add` was a normal method we'ld only print `"Hi"` once.
 If we make the parameter of `~` and `|` call-by-name, our `Parser` will work. Try it and you'll see another issue---the way the grammar is written we'll stop after parsing the first number. (Try `expression.parse("123+456")` and you'll see.) The solution is to rewrite the grammar so we look for compound expressions first and we proceed left-to-right.
 
 ~~~ scala
-object NumericParser {
-
+object NumericParser:
   val digits = Parser.regex("[0-9]").+
 
   def expression: Parser =
     (digits ~ Parser.string("+") ~ expression) | (digits ~ Parser.string("-") ~ expression) | digits
-
-}
 ~~~
 
 The code is tagged with `parser-numeric-expression`.

src/pages/case-studies/parser/intro.md

@@ -32,18 +32,14 @@ package underscore.parser
 
 import scala.annotation.tailrec
 
-case class ParseResult(result: String, remainder: String) {
-
+case class ParseResult(result: String, remainder: String):
   def failed: Boolean =
     result.isEmpty
 
   def success: Boolean =
     !failed
 
-}
-
-case class Parser(parse: String => ParseResult) {
-
+case class Parser(parse: String => ParseResult):
   def ~(next: Parser): Parser = ???
 
   def `*`: Parser =
@@ -60,19 +56,14 @@ case class Parser(parse: String => ParseResult) {
       loop("", input)
     }
 
-}
-
-object Parser {
-
+object Parser:
   def string(literal: String): Parser =
     Parser { input =>
       if(input.startsWith(literal))
         ParseResult(literal, input.drop(literal.size))
       else
         ParseResult("", input)
     }
-
-}
 ~~~
 
 What does the code do? The first thing is to look at what a `Parser` is. It is basically a wrapper around a function `String => ParseResult`. The `String` parameter is the input to parse, and returned is the result of parsing that `String`.