Complete book

Author: Abhijit Sarkar

README.md

@@ -12,7 +12,11 @@ Official GitHub repo: https://github.com/scalawithcats/scala-with-cats
 4. [Monads](src/main/scala/ch04)
 5. [Monad Transformers](src/main/scala/ch05)
 6. [Semigroupal and Applicative](src/main/scala/ch06)
-7. [Foldable and Traverse]()(src/main/scala/ch07)
+7. [Foldable and Traverse](src/main/scala/ch07)
+8. [Case Study: Testing Asynchronous Code](src/main/scala/ch08)
+9. [Case Study: Map-Reduce](src/main/scala/ch09)
+10. [Case Study: Data Validation](src/main/scala/ch10)
+11. [Case Study: CRDTs](src/main/scala/ch11)
 
 ## Running tests
 

src/main/scala/ch04/MonadError.scala

@@ -7,13 +7,13 @@ import cats.syntax.applicativeError.catsSyntaxApplicativeErrorId
 4.5.4 Exercise: Abstracting
 Implement a method validateAdult with the following signature
 
-def validateAdult[F[_]](age: Int)(implicit me: MonadError[F, Throwable]): F[Int]
+def validateAdult[F[_]](age: Int)(using me: MonadError[F, Throwable]): F[Int]
 
 When passed an age greater than or equal to 18 it should return that value as a success.
 Otherwise it should return a error represented as an IllegalArgumentException.
  */
 object MonadError:
-  def validateAdult[F[_]](age: Int)(implicit me: CatsMonadError[F, Throwable]): F[Int] =
+  def validateAdult[F[_]](age: Int)(using me: CatsMonadError[F, Throwable]): F[Int] =
     if age >= 18
     then Monad[F].pure(age)
     else new IllegalArgumentException("Age must be greater than or equal to 18").raiseError[F, Int]

src/main/scala/ch08/UptimeClient.scala

@@ -0,0 +1,16 @@
+package ch08
+
+import cats.Monad
+import scala.concurrent.Future
+import cats.Id
+
+// 8 Case Study: Testing Asynchronous Code
+trait UptimeClient[F[_]: Monad]:
+  def getUptime(hostname: String): F[Int]
+
+trait RealUptimeClient extends UptimeClient[Future]:
+  def getUptime(hostname: String): Future[Int]
+
+class TestUptimeClient(hosts: Map[String, Int]) extends UptimeClient[Id]:
+  def getUptime(hostname: String): Int =
+    hosts.getOrElse(hostname, 0)

src/main/scala/ch08/UptimeService.scala

@@ -0,0 +1,14 @@
+package ch08
+
+import cats.syntax.traverse.toTraverseOps
+import cats.syntax.functor.toFunctorOps
+import cats.Applicative
+
+// traverse only works on sequences of values that have an Applicative.
+// In our original code we were traversing a List[Future[Int]].
+// There is an applicative for Future so that was fine.
+// In this version we are traversing a List[F[Int]].
+// We need to prove to the compiler that F has an Applicative.
+class UptimeService[F[_]: Applicative](client: UptimeClient[F]):
+  def getTotalUptime(hostnames: List[String]): F[Int] =
+    hostnames.traverse(client.getUptime).map(_.sum)

src/main/scala/ch09/MapReduce.scala

@@ -0,0 +1,35 @@
+package ch09
+
+import cats.Monoid
+import scala.concurrent.Future
+import cats.syntax.traverse.toTraverseOps
+import cats.syntax.foldable.toFoldableOps
+import scala.concurrent.ExecutionContext
+
+/*
+9 Case Study: Map-Reduce
+
+1. Start with an initial list of all the data we need to process
+2. Divide the data into batches, sending one batch to each CPU
+3. The CPUs run a batch-level map phase in parallel
+4. The CPUs run a batch-level reduce phase in parallel,
+   producing a local result for each batch
+5. Reduce the results for each batch to a single final result
+ */
+object MapReduce:
+  def parallelFoldMap[A, B: Monoid](values: Vector[A])(func: A => B)(using ExecutionContext): Future[B] =
+    val numCores  = Runtime.getRuntime.availableProcessors
+    val groupSize = (1.0 * values.size / numCores).ceil.toInt
+
+    values
+      .grouped(groupSize)
+      // grouped returns an Iterator but cats
+      // doesn't have a Traverse instance for Iterator,
+      // so, convert to Vector.
+      .toVector
+      // ExecutionContext.Implicits.global. This default context allocates
+      // a thread pool with one thread per CPU in our machine.
+      // When we create a Future the ExecutionContext schedules it for execution.
+      // If there is a free thread in the pool, the Future starts executing immediately.
+      .traverse(group => Future(group.foldMap(func)))
+      .map(_.combineAll)

src/main/scala/ch10/Check.scala

@@ -0,0 +1,84 @@
+package ch10
+
+import cats.data.NonEmptyList
+import cats.data.Kleisli
+import cats.syntax.apply.catsSyntaxTuple2Semigroupal
+import Predicate.*
+
+type Errors = NonEmptyList[String]
+
+def error(s: String): NonEmptyList[String] =
+  NonEmptyList(s, Nil)
+
+type Result[A] = Either[Errors, A]
+
+// Kleisli lets us sequence monadic transforms,
+// A => F[B] `flatMap` B => F[C]
+type Check[A, B] = Kleisli[Result, A, B]
+
+def check[A, B](func: A => Result[B]): Check[A, B] =
+  Kleisli(func)
+
+def checkPred[A](pred: Predicate[Errors, A]): Check[A, A] =
+  // Running the predicate produces a func of type:
+  //   A => Either[NonEmptyList[String], A]
+  //   = A => Result[A]
+  //
+  // We must be able to convert a Predicate to a function,
+  // as Kleisli only works with functions.
+  // When we convert a Predicate to a function,
+  // it should have type A => Either[E, A] rather than
+  // A => Validated[E, A] because Kleisli relies on the
+  // wrapped function returning a monad.
+  Kleisli[Result, A, A](pred.run)
+
+def longerThan(n: Int): Predicate[Errors, String] =
+  Predicate.lift(
+    error(s"Must be longer than $n characters"),
+    str => str.size > n
+  )
+
+val alphanumeric: Predicate[Errors, String] =
+  Predicate.lift(
+    error(s"Must be all alphanumeric characters"),
+    str => str.forall(_.isLetterOrDigit)
+  )
+
+def contains(char: Char): Predicate[Errors, String] =
+  Predicate.lift(
+    error(s"Must contain the character $char"),
+    str => str.contains(char)
+  )
+
+def containsOnce(char: Char): Predicate[Errors, String] =
+  Predicate.lift(
+    error(s"Must contain the character $char only once"),
+    str => str.filter(_ == char).size == 1
+  )
+
+// Kleisli[[A] =>> Either[Errors, A], String, String]
+val checkUsername: Check[String, String] =
+  checkPred(longerThan(3) `and` alphanumeric)
+
+val splitEmail: Check[String, (String, String)] =
+  check(_.split('@') match {
+    case Array(name, domain) =>
+      Right((name, domain))
+
+    case _ =>
+      Left(error("Must contain a single @ character"))
+  })
+
+val checkLeft: Check[String, String] =
+  checkPred(longerThan(0))
+
+val checkRight: Check[String, String] =
+  checkPred(longerThan(3) `and` contains('.'))
+
+val joinEmail: Check[(String, String), String] =
+  check:
+    case (l, r) =>
+      (checkLeft(l), checkRight(r)).mapN(_ + "@" + _)
+
+val checkEmail: Check[String, String] =
+  splitEmail `andThen` joinEmail

src/main/scala/ch10/Predicate.scala

@@ -0,0 +1,58 @@
+package ch10
+
+import cats.kernel.Semigroup
+import cats.data.Validated
+import cats.syntax.apply.catsSyntaxTuple2Semigroupal
+import cats.syntax.validated.catsSyntaxValidatedId
+import cats.syntax.semigroup.catsSyntaxSemigroup
+import cats.data.Validated.{Invalid, Valid}
+
+// 10 Case Study: Data Validation
+
+// Preciate is basically a wrapper around a function:
+//   A => Validated[E, A]
+sealed trait Predicate[E, A]:
+  import Predicate.*
+
+  def and(that: Predicate[E, A]): Predicate[E, A] =
+    And(this, that)
+
+  def or(that: Predicate[E, A]): Predicate[E, A] =
+    Or(this, that)
+
+  def run(using s: Semigroup[E]): A => Either[E, A] =
+    (a: A) => this(a).toEither
+
+  private def apply(a: A)(using s: Semigroup[E]): Validated[E, A] =
+    this match
+      case Pure(func) =>
+        func(a)
+
+      case And(left, right) =>
+        (left(a), right(a)).mapN((_, _) => a)
+
+      case Or(left, right) =>
+        left(a) match
+          case Valid(_) => Valid(a)
+          case Invalid(e1) =>
+            right(a) match
+              case Valid(_)    => Valid(a)
+              case Invalid(e2) => Invalid(e1 |+| e2)
+
+object Predicate:
+  private final case class And[E, A](
+      left: Predicate[E, A],
+      right: Predicate[E, A]
+  ) extends Predicate[E, A]
+
+  private final case class Or[E, A](
+      left: Predicate[E, A],
+      right: Predicate[E, A]
+  ) extends Predicate[E, A]
+
+  private final case class Pure[E, A](
+      func: A => Validated[E, A]
+  ) extends Predicate[E, A]
+
+  def lift[E, A](err: E, fn: A => Boolean): Predicate[E, A] =
+    Pure(a => if (fn(a)) a.valid else err.invalid)

src/main/scala/ch11/BoundedSemiLattice.scala

@@ -0,0 +1,21 @@
+package ch11
+
+import cats.kernel.CommutativeMonoid
+
+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
+
+    val empty: Int = 0
+
+  // given [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]

src/main/scala/ch11/GCounter.scala

@@ -0,0 +1,27 @@
+package ch11
+
+import cats.kernel.CommutativeMonoid
+import cats.syntax.semigroup.catsSyntaxSemigroup
+import cats.syntax.foldable.toFoldableOps
+
+// 11 Case Study: CRDTs
+trait GCounter[F[_, _], K, V]:
+  def increment(f: F[K, V])(k: K, v: V)(using CommutativeMonoid[V]): F[K, V]
+
+  def merge(f1: F[K, V], f2: F[K, V])(using BoundedSemiLattice[V]): F[K, V]
+
+  def total(f: F[K, V])(using CommutativeMonoid[V]): V
+
+object GCounter:
+  import KeyValueStoreSyntax.*
+
+  given [F[_, _], K, V](using KeyValueStore[F], 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
+      f.put(key, total)
+
+    def merge(f1: F[K, V], f2: F[K, V])(using BoundedSemiLattice[V]): F[K, V] =
+      f1 |+| f2
+
+    def total(f: F[K, V])(using CommutativeMonoid[V]): V =
+      f.values.combineAll

src/main/scala/ch11/KeyValueStore.scala

@@ -0,0 +1,39 @@
+package ch11
+
+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]
+
+  def getOrElse[K, V](f: F[K, V])(k: K, default: V): V =
+    get(f)(k).getOrElse(default)
+
+  def values[K, V](f: F[K, V]): List[V]
+
+object KeyValueStore:
+  given KeyValueStore[Map] with
+    def put[K, V](f: Map[K, V])(k: K, v: V): Map[K, V] =
+      f + (k -> v)
+
+    def get[K, V](f: Map[K, V])(k: K): Option[V] =
+      f.get(k)
+
+    override def getOrElse[K, V](f: Map[K, V])(k: K, default: V): V =
+      f.getOrElse(k, default)
+
+    def values[K, V](f: Map[K, V]): List[V] =
+      f.values.toList
+
+object KeyValueStoreSyntax:
+  extension [F[_, _], K, V](f: F[K, V])(using kvs: KeyValueStore[F])
+    def put(key: K, value: V) =
+      kvs.put(f)(key, value)
+
+    def get(key: K): Option[V] =
+      kvs.get(f)(key)
+
+    def getOrElse(key: K, default: V): V =
+      kvs.getOrElse(f)(key, default)
+
+    def values: List[V] =
+      kvs.values(f)

src/test/scala/ch02/MonoidSpec.scala

@@ -4,19 +4,18 @@ import org.scalatest.matchers.should.Matchers.shouldBe
 import ch02.Lib.add
 
 class MonoidSpec extends AnyFunSpec:
-  describe("Monoid"):
-    it("should be able to add integers"):
-      val ints = List(1, 2, 3)
-      add(ints) `shouldBe` 6
+  it("should add integers"):
+    val ints = List(1, 2, 3)
+    add(ints) `shouldBe` 6
 
-    it("should be able to add strings"):
-      val strings = List("Hi ", "there")
-      add(strings) `shouldBe` "Hi there"
+  it("should add strings"):
+    val strings = List("Hi ", "there")
+    add(strings) `shouldBe` "Hi there"
 
-    it("should be able to add sets"):
-      val sets = List(Set("A", "B"), Set("B", "C"))
-      add(sets) `shouldBe` Set("A", "B", "C")
+  it("should add sets"):
+    val sets = List(Set("A", "B"), Set("B", "C"))
+    add(sets) `shouldBe` Set("A", "B", "C")
 
-    it("should be able to add options"):
-      val opts = List(Option(22), Option(20))
-      add(opts) `shouldBe` Option(42)
+  it("should add options"):
+    val opts = List(Option(22), Option(20))
+    add(opts) `shouldBe` Option(42)

src/test/scala/ch03/TreeSpec.scala

@@ -4,11 +4,11 @@ import org.scalatest.matchers.should.Matchers.shouldBe
 import cats.syntax.functor.toFunctorOps
 
 class TreeSpec extends AnyFunSpec:
-  describe("Tree"):
-    it("should be able to map on leaf"):
+  describe("Tree functor"):
+    it("should map on leaf"):
       val actual = Tree.leaf(100).map(_ * 2)
       actual `shouldBe` Leaf(200)
 
-    it("should be able to map on branch"):
+    it("should map on branch"):
       val actual = Tree.branch(Tree.leaf(10), Tree.leaf(20)).map(_ * 2)
       actual `shouldBe` Branch(Leaf(20), Leaf(40))

src/test/scala/ch04/ReaderSpec.scala

@@ -3,7 +3,7 @@ import org.scalatest.funspec.AnyFunSpec
 import org.scalatest.matchers.should.Matchers.shouldBe
 
 class ReaderSpec extends AnyFunSpec:
-  it("DbReader should be able to check password"):
+  it("DbReader should check password"):
     val users = Map(
       1 -> "dade",
       2 -> "kate",

src/test/scala/ch04/StateSpec.scala

@@ -4,5 +4,5 @@ import org.scalatest.funspec.AnyFunSpec
 import org.scalatest.matchers.should.Matchers.shouldBe
 
 class StateSpec extends AnyFunSpec:
-  it("evalInput should be able to evaluate a post-order expression"):
+  it("evalInput should evaluate a post-order expression"):
     State.evalInput("1 2 + 3 4 + *") `shouldBe` 21