Styling and numbering for parts

- Styling in TOC
- Styling in content
- Parts have roman numerals
- Chapter numbering does not nest under part numbering

Author: noelwelsh

src/pages/bibliography.typ

@@ -1,3 +1,3 @@
 #import "stdlib.typ": info, warning, solution
 
-#bibliography("scala-with-cats.bib", style: "acm-sigproceedings-long-author-list.csl")
+#bibliography("scala-with-cats.bib", style: "acm-sigchi-proceedings.csl")

src/pages/fps.typ

@@ -16,46 +16,39 @@
     size: 12pt
 )
 
-#set heading(numbering: "1.")
-
-#show raw.where(block: true) :set block(fill: rgb("F7F7F7"), inset: 8pt, width: 100%)
-#show link :set text(rgb("#996666"))
 
 // Front matter
 #include "parts/frontmatter.typ"
 
 // Main matter
+#show raw.where(block: true) :set block(fill: rgb("F7F7F7"), inset: 8pt, width: 100%)
+#show link :set text(rgb("#996666"))
+
 #pagebreak(to: "odd")
 #set page(numbering: "1")
 #set heading(numbering: "1.")
 #counter(page).update(1)
 #counter(heading).update(0)
 
-// Intro
-#include  "intro/index.typ"
-#include  "intro/three-levels.typ"
-#include  "intro/what-is-fp.typ"
-
-// The remainder of the main matter is organized into parts
-// Offset headings by 1, so that part headings can be level 1 and chapter
-// headings are level 2
-#set heading(offset: 1)
+// The main matter is organized into parts
 // Start parts on an odd page
-#show <part>: it => {
+#show figure.where(kind: "part"): it => {
     pagebreak(weak: true, to: "odd")
-    it
+    set text(size: 24pt * 1.2 * 1.2)
+    align(left)[
+        #strong[#it.supplement #it.counter.display(it.numbering): #it.body]
+    ]
 }
 #show heading.where(level: 1): it => {
-    // Part heading starts on an odd page but we insert them based on the label
+    // 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)
     it
     v(12pt * 1.2 * 1.2)
 }
 #show heading.where(level: 2): it => {
-    // 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(size: 24pt * 1.2)
     it
     v(12pt * 1.2 * 1.2)
 }
@@ -77,6 +70,10 @@
     it
     v(12pt)
 }
+// Intro
+#include  "intro/index.typ"
+#include  "intro/three-levels.typ"
+#include  "intro/what-is-fp.typ"
 
 // Part 1: Foundations
 #include  "parts/part1.typ"

src/pages/intro/what-is-fp.typ

@@ -91,7 +91,7 @@ In a sense local reasoning and composition are two sides of the same coin. Local
 
 I've made arguments in favour of functional programming and I admit I am biased---I do believe it is a better way to develop code than imperative programming. However, is there any evidence to back up my claim? There has not been much research on the effectiveness of functional programming, but there has been a reasonable amount done on static typing. I feel static typing, particularly using modern type systems, serves as a good proxy for functional programming so let's look at the evidence there.
 
-In the corners of the Internet I frequent the common refrain is that #href("https://danluu.com/empirical-pl/")[static typing has neglible effect on productivity]. I decided to look into this and was surprised that the majority of the results I found support the claim that static typing increases productivity. For example, the literature review in #cite(<uesbeck19:human>, form: "prose") shows a majority of results in favour of static typing, in particular the most recent studies. However the majority of these studies are very small and use relatively inexperienced developers---which is noted in the review by Dan Luu. My belief is that functional programming comes into its own on larger systems. Furthermore, programming languages, like all tools, require proficiency to use effectively. I'm not convinced very junior developers have sufficient skill to demonstrate a significant difference between languages.
+In the corners of the Internet I frequent the common refrain is that #href("https://danluu.com/empirical-pl/")[static typing has neglible effect on productivity]. I decided to look into this and was surprised that the majority of the results I found support the claim that static typing increases productivity. For example, one literature review @uesbeck19:human finds a majority of results in favour of static typing, and in particular finds support amongst the more recent studies. However the majority of these studies are very small and use relatively inexperienced developers---which is noted in the review by Dan Luu. My belief is that functional programming comes into its own on larger systems. Furthermore, programming languages, like all tools, require proficiency to use effectively. I'm not convinced very junior developers have sufficient skill to demonstrate a significant difference between languages.
 
 To me the most useful evidence of the effectiveness of functional programming is that industry is adopting functional programming en masse. Consider, say, the widespread and growing adoption of Typescript and React. If we are to argue that FP as embodied by Typescript or React has no value we are also arguing that the thousands of Javascript developers who have switched to using them are deluded. At some point this argument becomes untenable.
 

src/pages/parts/frontmatter.typ

@@ -1,5 +1,7 @@
 #import "../stdlib.typ": title-page, heading-multiplier, heading-space-base, heading-base
 
+#let parts-and-headings = figure.where(kind: "part", outlined: true).or(heading.where(outlined: true))
+
 // Front matter heading styles
 #show heading.where(level: 1): it => {
     // Chapter heading starts on an odd page. Don't create a page break if the
@@ -27,6 +29,30 @@
     it
     v(12pt)
 }
+// Formatting part entries in the table of contents
+#show outline.entry: it => {
+  if it.element.func() == figure {
+      // // we're configuring part printing here, effectively recreating the default show impl with slight tweaks
+      let res =[Part ] + numbering(it.element.numbering, ..it.element.counter.at(it.element.location())) + [: ] + it.element.body
+
+      if it.fill != none {
+          res += [ ] + box(width: 1fr, it.fill) + [ ]
+      } else {
+          res += h(1fr)
+      }
+
+      res += it.page()
+      link(it.element.location(), res)
+  } else {
+    // we're doing indenting here
+    // h(1em * it.level) + it
+      link(
+          it.element.location(),
+          it.indented(it.prefix(), it.inner()),
+      )
+  }
+}
+
 // Front Matter
 
 // Half Title page
@@ -36,14 +62,30 @@
 #pagebreak(to: "odd")
 #title-page(half: false)
 
+// Copyright page
+#pagebreak(weak: true, to: "even")
+#align(horizon)[
+© Copyright 2022--#datetime.today().display("[year]") Noel Welsh.
+Licensed under CC BY-SA 4.0
+
+Portions of this work are based on _Scala with Cats_, by Dave
+Pereira-Gurnell and Noel Welsh. _Scala with Cats_ is licensed under
+CC BY-SA 3.0.
+
+Artwork by Jenny Clements.
+
+#v(2em, weak: true)
+
+Published by Inner Product Consulting Ltd, UK.
+]
 
 // Dedication
 #pagebreak(to: "odd")
 This book is dedicated to those who laid the path that I have followed, to those who will take up where I have left off, and to those who have joined me along the way.
 
 // Table of contents
 #pagebreak(to: "odd")
-#outline(depth: 3)
+#outline(target: parts-and-headings, depth: 3)
 
 // Preface
 #pagebreak(to: "odd")

src/pages/parts/part1.typ

@@ -1,6 +1,6 @@
 #import "../stdlib.typ": part
 
-#part("parts/part1.png", "Foundations", "sec:part:foundations")[
+#part[Foundations] <sec:part:foundations>
 
 In this first part of the book we're building the foundational strategies on
 which the rest of the book will build and elaborate. In @sec:adt we look at
@@ -12,4 +12,3 @@ artifacts. For example, we can label part of code as an algebraic data type or a
 type class. We'll also see strategies that help us write code but don't
 necessarily end up directly reflected in it, such as following the types.
 
-]

src/pages/parts/part2.typ

@@ -1,6 +1,6 @@
 #import "../stdlib.typ": part
 
-#part("parts/part2.png", "Type Classes", "sec:part:type-classes")[
+#part[Type Classes] <sec:part:type-classes>
 
 In this part of the book we move on to type classes.
 We looked at the implementation of type classes in @sec:type-classes.
@@ -13,4 +13,3 @@ while the case studies will focus on their role in design.
 In @sec:cats we introduce the #link("https://typelevel.org/cats")[Cats] library.
 Cats provides implementation of the type classes we're interested in,
 and so it saves a lot of time and typing to use it.
-]

src/pages/parts/part3.typ

@@ -1,3 +1,3 @@
 #import "../stdlib.typ": part
 
-#part("parts/part3.png", "Interpreters", "sec:part:interpreters")[]
+#part[Interpreters] <sec:part:interpreters>

src/pages/parts/part4.typ

@@ -1,3 +1,3 @@
 #import "../stdlib.typ": part
 
-#part("parts/part4.png", "Case Studies", "sec:part:case-study")[]
+#part[Case Studies] <sec:part:case-study>

src/pages/scala-with-cats.bib

@@ -197,7 +197,7 @@ @Article{pintrich02:metacognitive
 }
 
 @PhdThesis{uesbeck19:human,
-  author  = {Phillip Merlin Uesbeck},
+  author  = {Uesbeck, Phillip Merlin},
   title   = {On the human factors impact of polyglot programming on programmer productivity},
   school  = {University of Nevada, Las Vegas},
   year    = 2019,

src/pages/stdlib.typ

@@ -54,26 +54,12 @@
         #let v-space = v(2em, weak: true)
         #text(3em)[*#title*]
 
-        #v-space
-        #text(1.6em, authors)
-
         #if not half [
             #v-space
-            #text([Draft built on #datetime.today().display()])
-            #v-space
-
-            Copyright 2022--#datetime.today().display("[year]") Noel Welsh.
-            Licensed under CC BY-SA 4.0
-
-            Portions of this work are based on Scala with Cats, by Dave
-            Pereira-Gurnell and Noel Welsh. Scala with Cats is licensed under
-            CC BY-SA 3.0.
-
-            Artwork by Jenny Clements.
+            #text(1.6em, authors)
 
             #v-space
-
-            Published by Inner Product Consulting Ltd, UK.
+            #text([Draft built on #datetime.today().display()])
         ]
       ],
     ),
@@ -85,24 +71,18 @@
     link(destination)[#body #footnote(destination)]
 }
 
-// A part heading page
+// A part heading
 //
-// image-path: path to the hero image for this part
-// name: the name of part as printed in the book
-// tag: a tag for references to this part (e.g. "sec:part:one")
-// content: content in the part
-#let part(image-path, name, tag, content) = [
-    #align(center)[
-        #image(image-path, width: 50%)
-        #heading(level: 1)[
-            #name
-        ]
-        #label(tag)
-    ]
-    <part>
-
-    #content
-]
+// Typical use is
+// #part[Name] <label>
+#let part = figure.with(
+    // Matches the key of the counter above
+    kind: "part",
+    numbering: "I",
+    supplement: "Part",
+    // Empty caption so that parts can be included in the outline
+    caption: []
+)
 
 #let heading-multiplier = 1.2
 #let heading-base = 24pt