Some work on the Eval section

- Add and style tables
- Add cross-ref to structural section
- Use call-by-name instead of call by name

Author: noelwelsh

src/pages/codata/structural.typ

@@ -1,5 +1,6 @@
 #import "../stdlib.typ": info, warning, solution, exercise
 == Structural Recursion and Corecursion for Codata
+<sec:codata-structural>
 
 
 In this section we'll build a library for streams, also known as lazy lists. These are the codata equivalent of lists. Whereas a list must have a finite length, streams have an infinite length. We'll use this example to explore structural recursion and structural corecursion as applied to codata.
@@ -582,13 +583,13 @@ twos.take(5)
 
 We get the same result whether we use a method or a `lazy val`, because we are assuming that we are only dealing with pure computations that have no dependency on state that might change. In this case a `lazy val` simply consumes additional space to save on time.
 
-Recomputing a result every time it is needed is known as *call by name*, while caching the result the first time it is computed is known as *call by need*. These two different *evaluation strategies* can be applied to individual values, as we've done here, or across an entire programming. Haskell, for example, uses call by need; all values in Haskell are only computed the first time they are needed. Call by need is also commonly known as *lazy evaluation*. Another alternative, called *call by value*, computes results when they are defined instead of waiting until they are needed. This is the default in Scala.
+Recomputing a result every time it is needed is known as *call-by-name*, while caching the result the first time it is computed is known as *call-by-need*. These two different *evaluation strategies* can be applied to individual values, as we've done here, or across an entire programming. Haskell, for example, uses call-by-need; all values in Haskell are only computed the first time they are needed. call-by-need is also commonly known as *lazy evaluation*. Another alternative, called *call-by-value*, computes results when they are defined instead of waiting until they are needed. This is the default in Scala.
 
-We can illustrate the difference between call by name and call by need if we use an impure computation. 
+We can illustrate the difference between call-by-name and call-by-need if we use an impure computation. 
 For example, we can define a stream of random numbers.
 Random number generators depend on some internal state.
 
-Here's the call by name implementation, using the methods we have already defined.
+Here's the call-by-name implementation, using the methods we have already defined.
 
 ```scala mdoc:silent
 import scala.util.Random
@@ -605,7 +606,7 @@ randoms.take(5)
 randoms.take(5)
 ```
 
-Now let's define the same stream in a call by need style, using `lazy val`.
+Now let's define the same stream in a call-by-need style, using `lazy val`.
 
 ```scala mdoc:silent
 val randomsByNeed: Stream[Double] =
@@ -622,7 +623,7 @@ randomsByNeed.take(5)
 randomsByNeed.take(5)
 ```
 
-If we wanted a stream that had a different random number for each element but those numbers were constant, we could redefine `unfold` to use call by need.
+If we wanted a stream that had a different random number for each element but those numbers were constant, we could redefine `unfold` to use call-by-need.
 
 ```scala mdoc:silent
 def unfoldByNeed[A, B](seed: A, f: A => B, next: A => A): Stream[B] =

src/pages/fps.typ

@@ -16,6 +16,14 @@
 #show raw.where(block: true): set block(fill: rgb("F7F7F7"), inset: 8pt, width: 100%)
 #show raw.where(block: true): set text(size: 8pt)
 
+// Table styling
+#set table(
+    inset: 8pt,
+    stroke: (_, y) => if y >= 0 { (top: 0.8pt) }
+)
+#show table.cell: set align(start)
+#show table.cell.where(y: 0): set text(weight: "bold")
+
 
 // Front matter
 #include "parts/frontmatter.typ"

src/pages/monads/eval.typ

@@ -3,21 +3,21 @@
 <sec:monads:eval>
 
 
-[`cats.Eval`][cats.Eval] is a monad that allows us to
-abstract over different _models of evaluation_.
-We typically talk of two such models: _eager_ and _lazy_,
-also called _call-by-value_ and _call-by-name_ respectively.
-`Eval` also allows for a result to be _memoized_,
-which gives us _call-by-need_ evaluation.
-
-`Eval` is also _stack-safe_,
+`cats.Eval` is a monad that allows us to
+abstract over different *models of evaluation*.
+We first met this concept, also known as evaluation strategies, in @sec:codata-structural.
+We typically talk of two such models: *eager* and *lazy*,
+also called *call-by-value* and *call-by-name* respectively.
+`Eval` also allows for a result to be *memoized*,
+which gives us *call-by-need* evaluation.
+
+`Eval` is also *stack-safe*,
 which means we can use it in very deep recursions
 without blowing up the stack.
 
 
 === Eager, Lazy, Memoized, Oh My!
 
-
 What do these terms for models of evaluation mean?
 Let's see some examples.
 
@@ -26,7 +26,7 @@ We can see the evaluation model using
 a computation with a visible side-effect.
 In the following example,
 the code to compute the value of `x`
-happens at place where it is defined
+happens at the place where it is defined
 rather than on access.
 Accessing `x` recalls the stored value
 without re-running the code.
@@ -43,7 +43,7 @@ x // second access
 
 This is an example of call-by-value evaluation:
 
-- the computation is evaluated at point where it is defined (eager); and
+- the computation is evaluated at the point where it is defined (eager); and
 - the computation is evaluated once (memoized).
 
 
@@ -100,8 +100,7 @@ The final combination, eager and not memoized, is not possible.
 
 
 === Eval's Models of Evaluation
-
-
+fs
 `Eval` has three subtypes: `Now`, `Always`, and `Later`.
 They correspond to call-by-value, call-by-name, and call-by-need respectively.
 We construct these with three constructor methods,
@@ -172,17 +171,17 @@ z.value // second access
 ```
 
 
-The three behaviours are summarized below:
+The three behaviours are summarized below.
 
------------------------------------------------------------------------
-Scala              Cats                      Properties
------------------- ------------------------- --------------------------
-`val`              `Now`                     eager, memoized
-
-`def`              `Always`                  lazy, not memoized
-
-`lazy val`         `Later`                   lazy, memoized
------------------- ------------------------- --------------------------
+#align(center)[
+    #table(
+        columns: (auto, auto, auto),
+        table.header([*Scala*], [*Cats*], [*Properties*]),
+        [`val`], [`Now`], [eager, memoized],
+        [`def`], [`Always`], [lazy, not memoized],
+        [`lazy val`], [`Later`], [lazy, memoized]
+    )
+]
 
 === Eval as a Monad