Complete ch13

Abhijit Sarkar · Abhijit Sarkar · commit 685e6043e0ba · 2025-01-11T20:15:08.000-08:00
diff --git a/.mill-version b/.mill-version
@@ -1 +1 @@
-0.12.4
+0.12.5
diff --git a/.scalafmt.conf b/.scalafmt.conf
@@ -1,5 +1,5 @@
 version = "3.8.4-RC4"
 align.preset = more
-maxColumn = 120
+maxColumn = 100
 runner.dialect = scala3
 assumeStandardLibraryStripMargin = true
diff --git a/README.md b/README.md
@@ -20,6 +20,7 @@ The older code is available in branches.
 10. [Monad Transformers](ch10)
 11. [Semigroupal and Applicative](ch11)
 12. [Foldable and Traverse](ch12)
+13. [Indexed Types](ch13)
 
 ## Running tests
 ```
diff --git a/ch05/src/ExpressionT.scala b/ch05/src/ExpressionT.scala
@@ -17,7 +17,12 @@ enum ExpressionT:
       case Loop(expr: ExpressionT, k: Continuation)
       case Done(result: Double)
 
-    def loop2(left: ExpressionT, right: ExpressionT, cont: Continuation, op: (Double, Double) => Double): Call =
+    def loop2(
+        left: ExpressionT,
+        right: ExpressionT,
+        cont: Continuation,
+        op: (Double, Double) => Double
+    ): Call =
       Call.Loop(
         left,
         l => Call.Loop(right, r => Call.Continue(op(l, r), cont))
diff --git a/ch05/test/src/ExpressionCSpec.scala b/ch05/test/src/ExpressionCSpec.scala
@@ -6,5 +6,7 @@ import org.scalatest.matchers.should.Matchers.shouldBe
 class ExpressionCSpec extends AnyFunSpec:
   describe("ExpressionC"):
     it("eval"):
-      val fortyTwo = ((ExpressionC(15.0) + ExpressionC(5.0)) * ExpressionC(2.0) + ExpressionC(2.0)) / ExpressionC(1.0)
+      val fortyTwo = ((ExpressionC(15.0) + ExpressionC(5.0)) * ExpressionC(2.0) + ExpressionC(
+        2.0
+      )) / ExpressionC(1.0)
       fortyTwo.eval shouldBe 42.0d
diff --git a/ch05/test/src/ExpressionSpec.scala b/ch05/test/src/ExpressionSpec.scala
@@ -6,5 +6,6 @@ import org.scalatest.matchers.should.Matchers.shouldBe
 class ExpressionSpec extends AnyFunSpec:
   describe("Expression"):
     it("eval"):
-      val fortyTwo = ((Expression(15.0) + Expression(5.0)) * Expression(2.0) + Expression(2.0)) / Expression(1.0)
+      val fortyTwo =
+        ((Expression(15.0) + Expression(5.0)) * Expression(2.0) + Expression(2.0)) / Expression(1.0)
       fortyTwo.eval shouldBe 42.0d
diff --git a/ch05/test/src/ExpressionTSpec.scala b/ch05/test/src/ExpressionTSpec.scala
@@ -6,5 +6,7 @@ import org.scalatest.matchers.should.Matchers.shouldBe
 class ExpressionTSpec extends AnyFunSpec:
   describe("ExpressionT"):
     it("eval"):
-      val fortyTwo = ((ExpressionT(15.0) + ExpressionT(5.0)) * ExpressionT(2.0) + ExpressionT(2.0)) / ExpressionT(1.0)
+      val fortyTwo = ((ExpressionT(15.0) + ExpressionT(5.0)) * ExpressionT(2.0) + ExpressionT(
+        2.0
+      )) / ExpressionT(1.0)
       fortyTwo.eval shouldBe 42.0d
diff --git a/ch06/test/src/CatSpec.scala b/ch06/test/src/CatSpec.scala
@@ -8,7 +8,11 @@ import cats.syntax.eq.catsSyntaxEq
 class CatSpec extends AnyFunSpec:
   describe("Cat"):
     it("Show"):
-      Cat("Garfield", 41, "ginger and black").show shouldBe "Garfield is a 41 year-old ginger and black cat."
+      Cat(
+        "Garfield",
+        41,
+        "ginger and black"
+      ).show shouldBe "Garfield is a 41 year-old ginger and black cat."
 
     it("Eq"):
       val cat1 = Cat("Garfield", 38, "orange and black")
diff --git a/ch08/src/ch08.worksheet.sc b/ch08/src/ch08.worksheet.sc
@@ -38,7 +38,8 @@ val showString = Show[String]
 // trait Contravariant[F[_]]:
 //   def contramap[A, B](fa: F[A])(f: B => A): F[B]
 
-val showSymbol: Show[Symbol] = Contravariant[Show].contramap(showString)((sym: Symbol) => s"'${sym.name}")
+val showSymbol: Show[Symbol] =
+  Contravariant[Show].contramap(showString)((sym: Symbol) => s"'${sym.name}")
 
 showSymbol.show(Symbol("dave"))
 
diff --git a/ch09/src/Lib.scala b/ch09/src/Lib.scala
@@ -16,7 +16,9 @@ object Lib:
 
   // def validateAdult[F[_] : ([G[_]] =>> MonadError[G, Throwable]) as me](age: Int): F[Int] =
   def validateAdult[F[_]](age: Int)(using me: MonadError[F, Throwable]): F[Int] =
-    me.ensure(me.pure(age))(IllegalArgumentException("Age must be greater than or equal to 18"))(_ >= 18)
+    me.ensure(me.pure(age))(IllegalArgumentException("Age must be greater than or equal to 18"))(
+      _ >= 18
+    )
 
   /*
     9.6.5 Exercise: Safer Folding using Eval
diff --git a/ch13/src/Html.scala b/ch13/src/Html.scala
@@ -0,0 +1,62 @@
+package ch13
+
+// 13.2.1 API Protocols
+// Indexed codata allows us to enforce API protocols at compile-time.
+// Often these protocols are finite-state machines.
+
+// There are several rules for valid HTML12. We’re going to focus on the following:
+
+// Within the html tag there can only be a head and a body tag, in that order.
+// Within the head tag there must be exactly one title, and there can be any other
+// number of allowed tags (of which we’re only going to model link).
+// Within the body there can be any number of allowed tags
+// (of which we are only going to model h1 and p).
+sealed trait StructureState
+trait Empty  extends StructureState
+trait InHead extends StructureState
+trait InBody extends StructureState
+
+sealed trait TitleState
+trait WithoutTitle extends TitleState
+trait WithTitle    extends TitleState
+
+// Not a case class so external users cannot copy it
+// and break invariants
+final class Html[S <: StructureState, T <: TitleState](
+    head: Vector[String],
+    body: Vector[String]
+):
+  // Head tags ---------------------------------------------
+
+  def head(using S =:= Empty): Html[InHead, WithoutTitle] =
+    Html(head, body)
+
+  def title(
+      text: String
+  )(using S =:= InHead, T =:= WithoutTitle): Html[InHead, WithTitle] =
+    Html(head :+ s"<title>$text</title>", this.body)
+
+  def link(rel: String, href: String)(using S =:= InHead): Html[InHead, T] =
+    Html(head :+ s"<link rel=\"$rel\" href=\"$href\"/>", body)
+
+  // Body tags ---------------------------------------------
+
+  def body(using S =:= InHead, T =:= WithTitle): Html[InBody, WithTitle] =
+    Html(head, body)
+
+  def h1(text: String)(using S =:= InBody): Html[InBody, T] =
+    Html(head, body :+ s"<h1>$text</h1>")
+
+  def p(text: String)(using S =:= InBody): Html[InBody, T] =
+    Html(head, body :+ s"<p>$text</p>")
+
+  // Interpreter ------------------------------------------
+
+  override def toString(): String =
+    val h = head.mkString("  <head>\n    ", "\n    ", "\n  </head>")
+    val b = body.mkString("  <body>\n    ", "\n    ", "\n  </body>")
+
+    s"\n<html>\n$h\n$b\n</html>"
+
+object Html:
+  val empty: Html[Empty, WithoutTitle] = Html(Vector.empty, Vector.empty)
diff --git a/ch13/src/Html2.scala b/ch13/src/Html2.scala
@@ -0,0 +1,53 @@
+package ch13.html2
+
+// Exercise: HTML API Design
+sealed trait StructureState
+trait NeedsHead extends StructureState
+trait NeedsBody extends StructureState
+trait Complete  extends StructureState
+
+sealed trait TitleState
+trait WithoutTitle extends TitleState
+trait WithTitle    extends TitleState
+
+final class Head[S <: TitleState](contents: Vector[String]):
+  def title(text: String)(using S =:= WithoutTitle): Head[WithTitle] =
+    Head(contents :+ s"<title>$text</title>")
+
+  def link(rel: String, href: String): Head[S] =
+    Head(contents :+ s"<link rel=\"$rel\" href=\"$href\"/>")
+
+  override def toString(): String =
+    contents.mkString("  <head>\n    ", "\n    ", "\n  </head>")
+object Head:
+  val empty: Head[WithoutTitle] = Head(Vector.empty)
+
+final class Body(contents: Vector[String]):
+  def h1(text: String): Body =
+    Body(contents :+ s"<h1>$text</h1>")
+
+  def p(text: String): Body =
+    Body(contents :+ s"<p>$text</p>")
+
+  override def toString(): String =
+    contents.mkString("  <body>\n    ", "\n    ", "\n  </body>")
+object Body:
+  val empty: Body = Body(Vector.empty)
+
+final class Html[S <: StructureState](
+    head: Head[?],
+    body: Body
+):
+  def head(f: Head[WithoutTitle] => Head[WithTitle])(using
+      S =:= NeedsHead
+  ): Html[NeedsBody] =
+    Html(f(Head.empty), body)
+
+  def body(f: Body => Body)(using S =:= NeedsBody): Html[Complete] =
+    Html(head, f(Body.empty))
+
+  override def toString(): String =
+    s"\n<html>\n${head.toString()}\n${body.toString()}\n</html>"
+
+object Html:
+  val empty: Html[NeedsHead] = Html(Head.empty, Body.empty)
diff --git a/ch13/src/ch13.worksheet.sc b/ch13/src/ch13.worksheet.sc
@@ -0,0 +1,115 @@
+/*
+13.2 Indexed Codata
+The basic idea of indexed codata is to prevent methods being called unless certain conditions,
+encoded in types, are met. More precisely, methods are guarded by type equalities that callers
+must prove they satisfy to call a method. The contextual abstraction features, given instances
+and using clauses, are used to implement this in Scala.
+ */
+trait On
+trait Off
+
+trait Switch[A]:
+  def on(using ev: A =:= Off): Switch[On]
+  def off(using ev: A =:= On): Switch[Off]
+
+final case class SimpleSwitch[A]() extends Switch[A]:
+  /*
+  If a given instance A =:= B exists, then the type A is equal to the type B.
+  We never create these instances ourselves. Instead the compiler creates them for us.
+  In the on method, we are asking the compiler to construct an instance A =:= Off,
+  which can only be done if A is Off. This in turn means we can only call the method
+  when the Switch is Off. This is the core idea of indexed codata: we reflect states as types,
+  and restrict method calls to a subset of states.
+   */
+  def on(using ev: A =:= Off): Switch[On] =
+    SimpleSwitch()
+  def off(using ev: A =:= On): Switch[Off] =
+    SimpleSwitch()
+
+object SimpleSwitch:
+  val on: Switch[On]   = SimpleSwitch()
+  val off: Switch[Off] = SimpleSwitch()
+
+SimpleSwitch.on.off
+SimpleSwitch.off.on
+
+// Doesn't compile.
+// SimpleSwitch.on.on
+
+// Exercise: Torque
+// Below is the definition of Length we previously used. Your mission is to:
+
+// 1. implement a type Force, parameterized by a phantom type that represents the units of force;
+// 2. implement a type Torque, parameterized by a phantom type that represents the units of torque;
+// 3. define types Newtons and NewtonMetres to represent force in SI units;
+// 4. implement a method * on Force that accepts a Length and returns a Torque. It can only be
+//    called if the Force is in Newtons and the Length is in Metres. In this case the Torque is in
+//    NewtonMetres. (Torque is force times length.)
+
+trait Newtons
+trait Metres
+trait NewtonMetres
+
+final case class Length[Unit](value: Double):
+  def +(that: Length[Unit]): Length[Unit] =
+    Length[Unit](this.value + that.value)
+
+final case class Torque[Unit](value: Double)
+
+final case class Force[Unit](value: Double):
+  def *[L](length: Length[L])(using Unit =:= Newtons, L =:= Metres): Torque[NewtonMetres] =
+    Torque(this.value * length.value)
+
+ch13.Html.empty.head
+  .link("stylesheet", "styles.css")
+  .title("Our Amazing Webpage")
+  .body
+  .h1("Where Amazing Exists")
+  .p("Right here")
+  .toString
+
+// Doesn't compile.
+// Html.empty.head
+//   .link("stylesheet", "styles.css")
+//   .body
+//   .h1("This Shouldn't Work")
+
+ch13.html2.Html.empty
+  .head(_.title("Our Amazing Webpage"))
+  .body(_.h1("Where Amazing Happens").p("Right here"))
+  .toString()
+
+// 13.2.2 Beyond Equality Constraints
+/*
+We can use <:< for evidence of a subtyping relationship,
+and NotGiven for evidence that no given instance exists
+(with which we can test that types are not equal, for example).
+Beyond that, we can view any given instance as evidence.
+ */
+trait Feet
+trait Pounds
+trait PoundsFeet
+
+// An instance exists if A * B = C
+trait Multiply[A, B, C]
+object Multiply:
+  given Multiply[Metres, Newtons, NewtonMetres] = new Multiply {}
+  given Multiply[Feet, Pounds, PoundsFeet]      = new Multiply {}
+
+  // Exercise: Commutivitiy
+  // A * B == B * A
+  given commutative: [A, B, C] => Multiply[A, B, C] => Multiply[B, A, C] =
+    new Multiply {}
+
+final case class Length2[L](value: Double):
+  def *[F, T](that: Force2[F])(using Multiply[L, F, T]): Torque[T] =
+    Torque(this.value * that.value)
+
+final case class Force2[F](value: Double):
+  def *[L, T](that: Length2[L])(using Multiply[F, L, T]): Torque[T] =
+    Torque(this.value * that.value)
+
+Length2[Metres](3) * Force2[Newtons](4)
+Length2[Feet](3) * Force2[Pounds](4)
+// Commutative
+Force[Newtons](3) * Length[Metres](4)
