Update referencing style

EDA.Rmd

@@ -661,7 +661,7 @@ Typically, the first one or two arguments to a function are so important that yo
 The first two arguments to `ggplot()` are `data` and `mapping`, and the first two arguments to `aes()` are `x` and `y`.
 In the remainder of the book, we won't supply those names.
 That saves typing, and, by reducing the amount of boilerplate, makes it easier to see what's different between plots.
-That's a really important programming concern that we'll come back in [functions].
+That's a really important programming concern that we'll come back to in Chapter \@ref(functions).
 
 Rewriting the previous plot more concisely yields:
 

data-transform.Rmd

@@ -564,7 +564,7 @@ Naming things is hard, so this slows down our analysis.
 There's another way to tackle the same problem with the pipe, `%>%`:
 
 ```{r}
-delays <- flights %>% 
+sdelays <- flights %>% 
   group_by(dest) %>% 
   summarise(
     count = n(),
@@ -580,7 +580,7 @@ As suggested by this reading, a good way to pronounce `%>%` when reading code is
 
 Behind the scenes, `x %>% f(y)` turns into `f(x, y)`, and `x %>% f(y) %>% g(z)` turns into `g(f(x, y), z)` and so on.
 You can use the pipe to rewrite multiple operations in a way that you can read left-to-right, top-to-bottom.
-We'll use piping frequently from now on because it considerably improves the readability of code, and we'll come back to it in more detail in [pipes].
+We'll use piping frequently from now on because it considerably improves the readability of code, and we'll come back to it in more detail in Chapter \@ref(pipes).
 
 Working with the pipe is one of the key criteria for belonging to the tidyverse.
 The only exception is ggplot2: it was written before the pipe was discovered.

functions.Rmd

@@ -127,7 +127,7 @@ df$d <- rescale01(df$d)
 
 Compared to the original, this code is easier to understand and we've eliminated one class of copy-and-paste errors.
 There is still quite a bit of duplication since we're doing the same thing to multiple columns.
-We'll learn how to eliminate that duplication in [iteration], once you've learned more about R's data structures in [vectors].
+We'll learn how to eliminate that duplication with iteration in Chapter \@ref(iteration), once you've learned more about R's data structures in Chapter \@ref(vectors).
 
 Another advantage of functions is that if our requirements change, we only need to make the change in one place.
 For example, we might discover that some of our variables include infinite values, and `rescale01()` fails:

iteration.Rmd

@@ -2,7 +2,7 @@
 
 ## Introduction
 
-In [functions], we talked about how important it is to reduce duplication in your code by creating functions instead of copying-and-pasting.
+In Chapter \@ref(functions), we talked about how important it is to reduce duplication in your code by creating functions instead of copying-and-pasting.
 Reducing code duplication has three main benefits:
 
 1.  It's easier to see the intent of your code, because your eyes are drawn to what's different, not what stays the same.
@@ -164,7 +164,7 @@ There are four variations on the basic theme of the for loop:
 ### Modifying an existing object
 
 Sometimes you want to use a for loop to modify an existing object.
-For example, remember our challenge from [functions].
+For example, remember our challenge from Chapter \@ref(functions) on functions.
 We wanted to rescale every column in a data frame:
 
 ```{r}

program.Rmd

@@ -28,18 +28,18 @@ But this doesn't mean you should rewrite every function: you need to balance wha
 
 In the following four chapters, you'll learn skills that will allow you to both tackle new programs and to solve existing problems with greater clarity and ease:
 
-1.  In [pipes], you will dive deep into the **pipe**, `%>%`, and learn more about how it works, what the alternatives are, and when not to use it.
+1.  In Chapter \@ref(pipes), you will dive deep into the **pipe**, `%>%`, and learn more about how it works, what the alternatives are, and when not to use it.
 
 2.  Copy-and-paste is a powerful tool, but you should avoid doing it more than twice.
     Repeating yourself in code is dangerous because it can easily lead to errors and inconsistencies.
-    Instead, in [functions], you'll learn how to write **functions** which let you extract out repeated code so that it can be easily reused.
+    Instead, in Chapter \@ref(functions), you'll learn how to write **functions** which let you extract out repeated code so that it can be easily reused.
 
-3.  As you start to write more powerful functions, you'll need a solid grounding in R's **data structures**, provided by [vectors].
+3.  As you start to write more powerful functions, you'll need a solid grounding in R's **data structures**, provided by vectors, which we discuss in Chapter \@ref(vectors).
     You must master the four common atomic vectors, the three important S3 classes built on top of them, and understand the mysteries of the list and data frame.
 
 4.  Functions extract out repeated code, but you often need to repeat the same actions on different inputs.
     You need tools for **iteration** that let you do similar things again and again.
-    These tools include for loops and functional programming, which you'll learn about in [iteration].
+    These tools include for loops and functional programming, which you'll learn about in Chapter \@ref(iteration).
 
 ## Learning more
 

strings.Rmd

@@ -715,7 +715,7 @@ It returns a list:
 str_extract_all(more, colour_match)
 ```
 
-You'll learn more about lists in [lists](#lists) and [iteration].
+You'll learn more about lists in Section \@ref(lists) on lists and Chapter \@ref(iteration) on iteration.
 
 If you use `simplify = TRUE`, `str_extract_all()` will return a matrix with short matches expanded to the same length as the longest:
 

workflow-basics.Rmd

@@ -51,7 +51,7 @@ some.people.use.periods
 And_aFew.People_RENOUNCEconvention
 ```
 
-We'll come back to code style later, in [functions].
+We'll come back to code style later, in Chapter \@ref(functions) on functions.
 
 You can inspect an object by typing its name: