San serif headings, Typst format of ADT chapter

- Use Lato as the font for heading
- Tweak heading size
- Add `exercise` function to stdlib
- Reformat algebraic data type chapter to Typst syntax

Author: noelwelsh

src/pages/adt/algebra.typ

@@ -1,4 +1,4 @@
-#import "../stdlib.typ": info, warning, solution
+#import "../stdlib.typ": info, warning, solution, exercise
 == The Algebra of Algebraic Data Types
 
 
@@ -56,7 +56,7 @@ type IntOrString = Either[Int, String]
 ```
 
 
-==== Exercise: Identities {-}
+#exercise[Identities]
 
 
 Can you work out which Scala type corresponds to the identity $1$ for product types?
@@ -87,8 +87,8 @@ enum Permissions {
 Written in mathematical notation, this is
 
 $
-"Person" = "String" times "Permissions"
-"Permissions" = "User" + "Moderator"
+    "Person" &= "String" times "Permissions" \
+    "Permissions" &= "User" + "Moderator"
 $
 
 Performing substitution gets us

src/pages/adt/conclusions.typ

@@ -1,4 +1,4 @@
-#import "../stdlib.typ": info, warning, solution
+#import "../stdlib.typ": href
 == Conclusions
 
 
@@ -25,18 +25,18 @@ Below are some references that you might find useful if you want to dig in furth
 
 Algebraic data types are standard in introductory material on functional programming. 
 Structural recursion is certainly extremely common in functional programming, but strangely seems to rarely be explicitly defined as I've done here.
-I learned about both from #cite(<felleisen18:htdp>, form: "prose").
+I learned about both from _How to Design Programs_ @felleisen18:htdp.
 
 I'm not aware of any approachable yet thorough treatment of either algebraic data types or structural recursion.
 Both seem to have become assumed background of any researcher in the field of programming languages,
 and relatively recent work is caked in layers of mathematics and obtuse notation that I find difficult reading.
 The infamous _Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire_ @meijer91:bananas is an example of such work.
 I suspect the core ideas of both date back to at least the emergence of computability theory in the 1930s, well before any digital computers existed.
 
-The earliest reference I've found to structural recursion is #cite(<burstall69:proving>, form: "prose").
-Algebraic data types don't seem to have been fully developed, along with pattern matching, until #link("https://en.wikipedia.org/wiki/NPL_(programming_language)")[NPL] in 1977.
-NPL was quickly followed by the more influential language #link("https://en.wikipedia.org/wiki/Hope_(programming_language)")[Hope], which spread the concept to other programming languages.
+The earliest reference I've found to structural recursion is _Proving Properties of Programs by Structural Induction_ @burstall69:proving.
+Algebraic data types don't seem to have been fully developed, along with pattern matching, until #href("https://en.wikipedia.org/wiki/NPL_(programming_language)")[NPL] in 1977.
+NPL was quickly followed by the more influential language #href("https://en.wikipedia.org/wiki/Hope_(programming_language)")[Hope], which spread the concept to other programming languages.
 
-Corecursion is a bit better documented in the contemporary literature. _How to Design Co-Programs_ #cite(<gibbons21:htdcp>, form: "prose") covers the main ideas we have looked at here, while #cite(<gibbons98:unfold>, form: "prose") discusses uses of `unfold`.
+Corecursion is a bit better documented in the contemporary literature. _How to Design Co-Programs_ @gibbons21:htdcp covers the main ideas we have looked at here, while _The under-appreciated unfold_ @gibbons98:unfold discusses uses of `unfold`.
 
-#cite(<mcbride01:deriv>, form: "prose") describes the derivative of algebraic data types.
+_The Derivative of a Regular Type is its Type of One-Hole Contexts_ @mcbride01:deriv describes the derivative of algebraic data types.

src/pages/adt/scala.typ

@@ -1,4 +1,4 @@
-#import "../stdlib.typ": info, warning, solution
+#import "../stdlib.typ": exercise, solution
 == Algebraic Data Types in Scala 
 
 
@@ -47,7 +47,7 @@ enum A {
 }
 ```
 
-In other words we don'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.
+In other words we don't write `final case class` inside an `enum`. You also can't nest an `enum` inside an `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
@@ -212,8 +212,7 @@ We've seen that the Scala 3 representation of algebraic data types, using `enum`
 - Scala 2's representation can express things that are almost, but not quite, algebraic data types. For example, if you define a method on an `enum` you must be able to define it for all the members of the `enum`. Sometimes you want a case of an `enum` to have methods that are only defined for that case. To implement this you'll need to use the Scala 2 representation instead. 
 
 
-==== Exercise: Tree {-}
-
+#exercise[Tree]
 
 To gain a bit of practice defining algebraic data types, code the following description in Scala (your choice of version, or do both.)
 

src/pages/adt/structural-corecursion.typ

@@ -1,4 +1,4 @@
-#import "../stdlib.typ": info, warning, solution
+#import "../stdlib.typ": info, warning, solution, exercise
 == Structural Corecursion
 
 
@@ -9,10 +9,7 @@ Whereas we can use structural recursion whenever the input of a method or functi
 we can use structural corecursion whenever the output of a method or function is an algebraic data type.
 
 
-#info[
-==== Duality in Functional Programming {-}
-
-
+#info(title: [Duality in Functional Programming])[
 Two concepts or structures are duals if one can be translated in a one-to-one fashion to the other.
 Duality is one of the main themes of this book.
 By relating concepts as duals we can transfer knowledge from one domain to another.
@@ -363,7 +360,7 @@ MyList.fill(5)(getAndInc())
 ```
 
 
-==== Exercise: Iterate {-}
+#exercise[Iterate]
 
 
 Implement `iterate` using the same reasoning as we did for `fill`.
@@ -397,7 +394,7 @@ MyList.iterate(0, 5)(x => x - 1)
 ]
 
 
-==== Exercise: Map {-}
+#exercise[Map]
 
 
 Once you've completed `iterate`, try to implement `map` in terms of `unfold`. You'll need to use the destructors to implement it.

src/pages/adt/structural-recursion.typ

@@ -1,4 +1,4 @@
-#import "../stdlib.typ": info, warning, solution
+#import "../stdlib.typ": info, warning, solution, exercise
 == Structural Recursion
 
 
@@ -315,7 +315,7 @@ In these situations we can use dynamic dispatch instead.
 We'll learn more about this when we look at generalized algebraic data types.
 
 
-==== Exercise: Methods for Tree {-}
+#exercise[Methods for Tree]
 
 
 In a previous exercise we created a `Tree` algebraic data type:
@@ -572,7 +572,7 @@ Returning to `MyList`, it has:
 - `Pair` is a constructor with one parameter of type `A` and one recursive parameter, and hence the corresponding function has type `(A, B) => B`.
 
 
-==== Exercise: Tree Fold {-}
+#exercise[Tree Fold]
 
 
 Implement a fold for `Tree` defined earlier.
@@ -640,7 +640,7 @@ enum Tree[A] {
 ]
 
 
-==== Exercise: Using Fold {-}
+#exercise[Using Fold]
 
 
 Prove to yourself that you can replace structural recursion with calls to fold, by redefining `size`, `contains`, and `map` for `Tree` using only fold.

src/pages/fps.typ

@@ -1,4 +1,4 @@
-#import "stdlib.typ": title, authors, heading-multiplier, heading-space-base, heading-base
+#import "stdlib.typ": title, authors
 
 #set document(
     title: title,
@@ -34,7 +34,10 @@
 // Start parts on an odd page
 #show figure.where(kind: "part"): it => {
     pagebreak(weak: true, to: "odd")
-    set text(size: 24pt * 1.2 * 1.2)
+    set text(
+        font: "Lato",
+        size: 12pt * 1.333 * 1.333 * 1.333
+    )
     align(left)[
         #strong[#it.supplement #it.counter.display(it.numbering): #it.body]
     ]
@@ -43,30 +46,33 @@
     // Chapter heading starts on an odd page. Don't create a page break if the
     // page is already empty.
     pagebreak(weak: true, to: "odd")
-    set text(size: 24pt * 1.2 * 1.2)
+    set text(
+        font: "Lato",
+        size: 12pt * 1.333 * 1.333 * 1.333)
     it
-    v(12pt * 1.2 * 1.2)
+    v(12pt * 1.333)
 }
 #show heading.where(level: 2): it => {
-    set text(size: 24pt * 1.2)
+    v(12pt)
+    set text(
+        font: "Lato",
+        size: 12pt * 1.333 * 1.333)
     it
-    v(12pt * 1.2 * 1.2)
+    v(12pt * 1.333)
 }
 #show heading.where(level: 3): it => {
-    v(heading-space-base)
-    set text(size: heading-base)
-    it
-    v(12pt)
-}
-#show heading.where(level: 4): it => {
     v(12pt / 1.2)
-    set text(size: 1.44em / 1.2)
+    set text(
+        font: "Lato",
+        size: 12pt * 1.333)
     it
     v(12pt)
 }
-#show heading.where(level: 5): it => {
+#show heading.where(level: 4): it => {
     v(12pt / 1.2 / 1.2)
-    set text(size: 1.44em / 1.2 / 1.2)
+    set text(
+        font: "Lato",
+        size: 12pt)
     it
     v(12pt)
 }

src/pages/parts/frontmatter.typ

@@ -1,4 +1,4 @@
-#import "../stdlib.typ": title-page, heading-multiplier, heading-space-base, heading-base
+#import "../stdlib.typ": title-page
 
 #let parts-and-headings = figure.where(kind: "part", outlined: true).or(heading.where(outlined: true))
 
@@ -7,25 +7,33 @@
     // Chapter heading starts on an odd page. Don't create a page break if the
     // page is already empty.
     pagebreak(weak: true, to: "odd")
-    set text(size: 24pt * 1.2 * 1.2)
+    set text(
+        font: "Lato",
+        size: 12pt * 1.333 * 1.333 * 1.333)
     it
-    v(12pt * 1.2 * 1.2)
+    v(12pt * 1.333)
 }
 #show heading.where(level: 2): it => {
-    v(heading-space-base)
-    set text(size: heading-base)
-    it
     v(12pt)
+    set text(
+        font: "Lato",
+        size: 12pt * 1.333 * 1.333)
+    it
+    v(12pt * 1.333)
 }
 #show heading.where(level: 3): it => {
     v(12pt / 1.2)
-    set text(size: 24pt / 1.2)
+    set text(
+        font: "Lato",
+        size: 12pt * 1.333)
     it
     v(12pt)
 }
 #show heading.where(level: 4): it => {
     v(12pt / 1.2 / 1.2)
-    set text(size: 24pt / 1.2 / 1.2)
+    set text(
+        font: "Lato",
+        size: 12pt)
     it
     v(12pt)
 }
@@ -91,6 +99,8 @@ This book is dedicated to those who laid the path that I have followed, to those
 #pagebreak(to: "odd")
 #set page(numbering: "i")
 #set heading(numbering: none)
+#show link :set text(rgb("#996666"))
+
 #include  "../preface/preface.typ"
 #include  "../preface/versions.typ"
 #include  "../preface/conventions.typ"

src/pages/stdlib.typ

@@ -1,15 +1,15 @@
-#let callout(body, title: "", fill: blue, title-color: white, body-color: black) = {
+#let callout(body, title: none, fill: blue, title-color: white, body-color: black) = {
     block(
         stroke: (left: 8pt + fill),
         fill: color.mix((white, 70%), (fill, 30%)),
         width: 100%,
         inset: 16pt
     )[
-        #if title.len() == 0 {
+        #if title == none {
             text(body-color)[#body]
         } else {
             [
-                #heading(level: 4, outlined: false, title)
+                #heading(depth: 4, numbering: none, outlined: false, title)
                 #text(body-color)[#body]
             ]
         }
@@ -84,6 +84,7 @@
     caption: []
 )
 
-#let heading-multiplier = 1.2
-#let heading-base = 24pt
-#let heading-space-base = 12pt
+
+#let exercise(title) = {
+    heading(depth: 4, numbering: none, outlined: false, "Exercise: " + title)
+}