R Programming (Continued)
27 August 2026
In R, we do things using functions, as soon as we use it beyond a calculator.
We have already seen and used a multitude of functions in R.
mean())mvtnorm::rmvnorm())Regardless of where they come from, functions in R all adopt the same basic syntax:
Most of the time we rely on functions that other people have written for us. But you can, and should, write your own too, with the generic function() function.1
1 Yes, it is a function that lets you write functions. Very meta.
Writing anonymous functions like the above is possible and reasonably common. But we typically write functions because we want to reuse code, and for that it makes sense to name them.1
Tip
Try to give your functions short, pithy names that are informative to both you and anyone else reading your code. This is harder than it sounds, but will pay off down the road.
Two things we still owe you, and which the next few slides deliver:
return() actually matter;Caution
R’s default behaviour is to automatically return the final object that you created within the function. However, this won’t always be the case. Get into the habit of assigning the return object(s) explicitly.
An explicit return() is also how we hand back more than one object:
You can also assign default argument values. You have encountered examples of this already.1
1 E.g. type ?rnorm and see that it provides a default mean and standard deviation of 0 and 1, respectively.
None of the intermediate objects created inside the functions above (total, etc.) made their way into our global environment. Confirm this in the “Environment” pane of RStudio.
R has a set of lexical scoping rules governing where it stores and evaluates the values of different objects.
return() command.Consider a simple linear regression model with a constant term and one regressor:
y_i = \beta_0 + \beta_1 x_i + \varepsilon_i
In matrix notation:
\mathbf{y} = \mathbf{X}\boldsymbol{\beta} + \boldsymbol{\varepsilon}
The OLS estimator is given by
\hat{\boldsymbol{\beta}} = (\mathbf{X}' \mathbf{X})^{-1} \mathbf{X}'\mathbf{y}
To conduct OLS estimation in R, we literally translate this mathematical expression into code.
We need data Y and X to run OLS, so we simulate an artificial dataset.
\hat{\boldsymbol{\beta}} = (\mathbf{X}' \mathbf{X})^{-1} \mathbf{X}'\mathbf{y} becomes one line of R.
## [,1]
## [1,] 0.9861773
## [2,] 0.9404956## [1] "matrix" "array"solve(A, b) solves Ax = b, which is numerically better behaved than forming the inverse with solve(A) %*% b.
## X1 X2
## 0.9861773 0.9404956## [1] "numeric"Same numbers, three routes. Note that the returned class differs.
Scatter points, the fitted regression line (black) and the true coefficient line (red).
In econometrics we are often interested in hypothesis testing, and the t-statistic is widely used. To test H_0: \beta_1 = 1, again a translation:
t = \frac{\hat{\beta}_1 - \beta_{01}}{ \hat{\sigma}_{\hat{\beta}_1} } = \frac{\hat{\beta}_1 - \beta_{01}}{ \sqrt{ \left[ (X'X)^{-1} \hat{\sigma}^2 \right]_{22} } },
where [\cdot]_{22} is the (2,2)-element of a matrix.
## [1] -0.5615293Exercise (in Homework 1): can you write a function with both \hat{\beta} and the t-value as outputs?
Looking inside a function is not only important for debugging, it is also a great way to pick up programming tips and tricks.
dplyr::bind_rows.You can still view the source, it just takes more legwork:
A base R installation is relatively compact. R’s true power lies in its extensive ecosystem of add-on packages, most of them hosted on CRAN, the Comprehensive R Archive Network.
A common practice in the statistical community: researchers publish an R package alongside the academic paper.
A package is installed by install.packages("package_name") and invoked by library(package_name).
To install ggplot2, either:
install.packages("ggplot2").
Once installed, load a package into your R session with library().
Note
Notice that you do not need quotes around the package name any more.
Reason: R now recognizes the package as a defined object with a given name. (“Everything in R is an object and everything has a name.”)
Tip
A convenient way to combine installation and loading is the pacman package’s p_load() function. pacman::p_load(ggplot2) first checks whether it needs to install the package, then loads it. Clever.
We can also run a function from an installed package without loading it, using PACKAGE::package_function():
Many authors distribute packages through GitHub or their personal websites, especially for cutting-edge research or development versions.
Why build a package?
Core tools: RStudio Projects, usethis, devtools, roxygen2, testthat, knitr, styler.
The standard reference is Wickham and Bryan’s R Packages.
create_package() → open projectuse_git() → commituse_r() → write function(s) in R/document()load_all() to try codeuse_testthat() → write tests → test()use_package() for deps (avoid library() in code)use_vignette(), use_data()use_readme_rmd() → build_readme()check() → install() → build() → (optional) use_github()A modern approach to developing R packages is through literate programming.
Rmd file.Interested? The videos show how it works in a few minutes.
Now that we have a good sense of the basic function syntax, it is time to learn control flow: controlling the order, or “flow”, of the statements and operations that our functions evaluate.
This is common to all programming languages.
if is used for choice.for and while are used for loops.ifThe basic syntax for an if statement:
if ... elseWe can extend this with an else statement to handle alternative conditions:
ifelse()For simple conditional operations, ifelse() provides a more concise syntax:
ifelse()Warning
The base R ifelse() function normally works great, and I use it all the time. But there are a couple of “gotcha” cases you should be aware of.
Consider this silly function, designed to return either today’s date or the day before:
## [1] "2026-08-27"## [1] "2026-08-26"## [1] 20692A number, not a date!
ifelse() (cont.)Why: ifelse() automatically converts date objects to numeric, as a way to get around some other type conversion strictures.
as.Date(today(TRUE), origin = "1970-01-01").Aside: the “dot-dot-dot” argument (...) used above is a convenient shortcut that allows users to enter unspecified arguments into a function.
To guard against this behaviour, and to add some other optimisations, both the tidyverse (through dplyr) and data.table offer their own versions of ifelse.
ifelse()As you may have guessed, it is certainly possible to write nested ifelse() statements:
or
However, these nested statements quickly become difficult to read and troubleshoot.
A better solution was originally developed in SQL with the CASE WHEN statement. Both dplyr (case_when()) and data.table (fcase()) provide implementations in R.
## [1] "small" "small" "small" "medium" "medium" "medium" "medium" "big"
## [9] "big" "big"## [1] "small" "small" "small" "medium" "medium" "medium" "medium" "big"
## [9] "big" "big"Alongside control flow, the most important early programming skill to master is iteration.
In particular, we want to write functions that can iterate, or map, over a set of inputs.
By far the most common way to iterate, across programming languages, is the for loop.
When we use loops, we should minimize the tasks within the loop.
NULL) object, and R re-allocates memory at every iteration.Let us measure how much this actually costs.
## [1] 0.95023## Takes 7.249099 seconds## [1] 0.94893## Takes 2.395516 secondsIdentical answer, and the empirical coverage sits close to the nominal 95%. Pre-allocating is the cheaper route.
Before we write any loops, we should ask ourselves: “Do I need to iterate at all?”
R is vectorized. Often you can apply a function to every element of a vector at once, rather than one at a time.
… or just a_vec * b_vec.
Borrowed from Ross Ihaka’s online note.
for looprw2d_loop <- function(n) {
xpos <- rep(0, n)
ypos <- rep(0, n)
xdir <- c(TRUE, FALSE)
step_size <- c(1, -1)
for (i in 2:n) {
if (sample(xdir, 1)) {
xpos[i] <- xpos[i - 1] + sample(step_size, 1)
ypos[i] <- ypos[i - 1]
} else {
xpos[i] <- xpos[i - 1]
ypos[i] <- ypos[i - 1] + sample(step_size, 1)
}
}
return(data.frame(x = xpos, y = ypos))
}The trick: draw all n-1 directions in one call, then cumsum() the steps.
## Naive implementation: 0.329658## Vectorized implementation: 0.001796007Two orders of magnitude, for the same random walk.
Loops can run very slowly, and an inconspicuous for loop has been known to bring an entire analysis crashing to its knees.1
The bigger problem with for loops, however, is that they deviate from the norms and best practices of functional programming.
1 Exhibit A.
Functional programming (FP) is arguably the most important thing you can take away from today’s lecture. Hadley Wickham puts the core idea like this in Advanced R:
R, at its heart, is a functional programming (FP) language. […] R has what’s known as first class functions.
You can do anything with a function that you can do with a vector:
Summary: for loops emphasise the objects we are working with (say, a vector of numbers) rather than the operations we want to apply to them (get the mean, or the median, or whatever).
i is sitting there, equal to the last value of its loop.Another annoyance arrived in cases where we want to “grow” an object as we iterate over it. To do that with a for loop, we had to create an empty object first.
FP lets us avoid the explicit loop construct and its associated downsides. In practice, there are two ways to implement FP in R:
*apply family of functions in base R.map*() family of functions from purrr.Let’s explore these in more depth.
lapply()Its syntax closely mimics the syntax of a basic for-loop.
## [[1]]
## [1] "A"
##
## [[2]]
## [1] "B"
##
## [[3]]
## [1] "C"
##
## [[4]]
## [1] "D"
##
## [[5]]
## [1] "E"
##
## [[6]]
## [1] "F"
##
## [[7]]
## [1] "G"
##
## [[8]]
## [1] "H"
##
## [[9]]
## [1] "I"
##
## [[10]]
## [1] "J"i in your global environment. Because of R’s lexical scoping rules, any object created and invoked by a function is evaluated in a sandbox outside your global environment.for() to lapply(). The essential structure is the same: first the iteration list (1:10), then the desired function or operation (LETTERS[i]).lapply() accepts vectors, data frames and lists as arguments, but always returns a list, with one element per iteration of the loop. (So now you know where the “l” in “lapply” comes from.)Several options exist.1 The one I use most commonly is to bind the list elements into a single data frame with dplyr::bind_rows() or data.table::rbindlist().
## # A tibble: 10 × 2
## num let
## <int> <chr>
## 1 1 A
## 2 2 B
## 3 3 C
## 4 4 D
## 5 5 E
## 6 6 F
## 7 7 G
## 8 8 H
## 9 9 I
## 10 10 J1 E.g. pipe the output to unlist() if you want a vector, or use sapply(), which is covered next.
lapply() anyway?The default list-return behaviour may not sound ideal at first, but I use lapply() more frequently than any of the other apply family members.
dplyr::bind_rows() and data.table::rbindlist() come in.*apply family: sapply()sapply() stands for “simplify apply”. It is essentially a wrapper around lapply that tries to return simplified output that matches the input type. Feed it a vector and it will try to return a vector.
*apply family: apply()apply() applies functions over array margins: the rows or columns of matrices and data frames.
## [,1] [,2] [,3] [,4]
## [1,] 1 4 7 10
## [2,] 2 5 8 11
## [3,] 3 6 9 12## [1] 2 5 8 11## [1] 5.5 6.5 7.5For a concise overview of the different *apply() functions, see this blog post by Neil Saunders.
purrr’s map() is the tidyverse’s lapply(). Same syntax, same list output:
## [[1]]
## # A tibble: 1 × 2
## num let
## <int> <chr>
## 1 1 A
##
## [[2]]
## # A tibble: 1 × 2
## num let
## <int> <chr>
## 1 2 B
##
## [[3]]
## # A tibble: 1 × 2
## num let
## <int> <chr>
## 1 3 C
##
## [[4]]
## # A tibble: 1 × 2
## num let
## <int> <chr>
## 1 4 D
##
## [[5]]
## # A tibble: 1 × 2
## num let
## <int> <chr>
## 1 5 E
##
## [[6]]
## # A tibble: 1 × 2
## num let
## <int> <chr>
## 1 6 F
##
## [[7]]
## # A tibble: 1 × 2
## num let
## <int> <chr>
## 1 7 G
##
## [[8]]
## # A tibble: 1 × 2
## num let
## <int> <chr>
## 1 8 H
##
## [[9]]
## # A tibble: 1 × 2
## num let
## <int> <chr>
## 1 9 I
##
## [[10]]
## # A tibble: 1 × 2
## num let
## <int> <chr>
## 1 10 Jmap_df(): pick your output typemap() comes with its own variants for returning objects of a desired type. purrr::map_df() returns a data frame:
## # A tibble: 10 × 2
## num let
## <int> <chr>
## 1 1 A
## 2 2 B
## 3 3 C
## 4 4 D
## 5 5 E
## 6 6 F
## 7 7 G
## 8 8 H
## 9 9 I
## 10 10 JMore efficient, i.e. less typing, than the lapply() version: no extra row-binding step at the end. Jenny Bryan’s purrr tutorial goes much deeper.
We can split the function and the iteration (and binding) into separate steps. This is generally a good idea, since you typically create named functions with the goal of reusing them.
Now we can easily iterate over our function using different input values.
A document format that combines the power of R programming with the simplicity of Markdown syntax. Code, results, and narrative text coexist seamlessly.
R Markdown provides an authoring framework for data science. You can use a single R Markdown file to both
- save and execute code
- generate high quality reports that can be shared with an audience
An R Markdown document consists of three main components:
---{r}This deck, and the long-form note it mirrors, are themselves such documents.
Code chunks are the heart of R Markdown. They allow you to:
echo=FALSE, eval=FALSE;Quarto (.qmd) represents the next generation of R Markdown, building upon its foundation while introducing significant improvements.
For comprehensive documentation and tutorials, visit the Quarto website.