Chapter 50: R & the Tidyverse

R's Data Model

Everything in R is a vector. Unlike Python, where a scalar 42 is an int object, in R 42 is a numeric vector of length 1. This single idea explains most of R's surprising behaviors.

x <- c(1, 2, 3, 4, 5)   # c() "combines" scalars into a vector
class(x)                  # "numeric"
length(x)                 # 5
x[2]                      # 2  (R is 1-indexed!)
x[c(1, 3)]                # 1 3
x > 3                     # FALSE FALSE FALSE TRUE TRUE  (logical vector)
x[x > 3]                  # 4 5  (logical subsetting)

The <- assignment arrow is idiomatic R; = works too but is typically reserved for function arguments.

Atomic Vector Types

R has six atomic types. The ones you will use daily:

• logical — TRUE / FALSE (Python: bool)
• integer — 1L, 2L (the L suffix marks integer literals)
• double — 3.14 (Python: float; this is the default numeric type)
• character — "hello" (Python: str)
• factor — categorical variable with fixed levels (Python: pd.Categorical)

Factors deserve special mention because they appear constantly in statistical output and plotting:

status <- factor(c("low", "high", "med", "high", "low"),
                 levels = c("low", "med", "high"))
table(status)   # counts per level, in level order
nlevels(status) # 3

forcats (part of the Tidyverse) provides helpers like fct<em>reorder, fct</em>lump, and fct<em>relevel for manipulating factors — essential before feeding categoricals to ggplot2.

Lists

A list is R's heterogeneous container — the Python dict / list hybrid:

person <- list(name = "Ada", age = 36, scores = c(95, 87, 92))
person$name       # "Ada"      ($ is like Python .attribute)
person[["age"]]   # 36        (double brackets extract the value)
person["age"]     # a list of length 1 (single brackets keep the list wrapper)

Data Frames and Tibbles

A data frame is a named list of equal-length vectors — directly analogous to a pandas DataFrame. A tibble (tbl</em>df) is the Tidyverse's improved version:

• Never converts strings to factors automatically (unlike base data.frame).
• Prints only the first 10 rows and truncates wide columns.
• Gives informative errors on non-existent column access instead of silently returning NULL.

library(tibble)

df <- tibble(
  name   = c("Alice", "Bob", "Carol"),
  score  = c(88, 95, 72),
  passed = score >= 75          # you can reference earlier columns!
)
df
# A tibble: 3 × 3
#   name  score passed
#   <chr> <dbl> <lgl>
# 1 Alice    88 TRUE
# 2 Bob      95 TRUE
# 3 Carol    72 FALSE

Notice the column type tags (<chr>, <dbl>, <lgl>) printed beneath headers — a convenience absent from base data frames.

Python ↔ R Quick Reference

• pd.DataFrame({...}) → tibble(...)
• df['col'] → df$col or df[['col']]
• df.shape → dim(df) or nrow(df) / ncol(df)
• df.dtypes → str(df) or glimpse(df) (from dplyr)
• df.head(10) → head(df, 10) or just df (tibble truncates automatically)
• df.describe() → summary(df)

Reading Data

readr (Tidyverse) reads rectangular text files faster than base R and returns tibbles:

library(readr)

students <- read_csv("students.csv")          # comma-separated
exams    <- read_tsv("exams.tsv")              # tab-separated
config   <- read_csv("data.csv",
             col_types = cols(
               id    = col_integer(),
               score = col_double(),
               date  = col_date(format = "%Y-%m-%d")
             ))

read<em>csv (with underscore) is readr's function; read.csv (with dot) is the slower base-R version. Prefer readr.

Missing Values

R uses NA (not NaN) as the universal missing-value sentinel. NA is typed: NA</em>real<em>, NA</em>integer<em>, NA</em>character_. Key behaviors:

is.na(NA)          # TRUE
sum(c(1, NA, 3))   # NA  (NA is contagious)
sum(c(1, NA, 3), na.rm = TRUE)  # 4

The na.rm = TRUE pattern recurs across virtually all R summary functions.

The Pipe Operator

R 4.1 introduced the native pipe |>. The Tidyverse also provides %>% (from magrittr). Both pass the left-hand result as the first argument to the right-hand function:

# These three are equivalent:
result <- summarise(group_by(filter(df, score > 50), group), mean_score = mean(score))

result <- df |> filter(score > 50) |> group_by(group) |> summarise(mean_score = mean(score))

# Formatted readably:
result <- df |>
  filter(score > 50) |>
  group_by(group) |>
  summarise(mean_score = mean(score))

The pipe transforms nested function calls into a left-to-right pipeline — the same pattern as pandas method chaining but more general because it works across any functions.

The Core dplyr Verbs

dplyr provides a small, consistent vocabulary for data transformation. Each verb takes a data frame as its first argument and returns a data frame — which is why they compose so naturally through the pipe.

filter — row selection

Equivalent to df[df['col'] > x] in pandas or WHERE in SQL:

library(dplyr)
data(nycflights13::flights, package = "nycflights13")

flights |>
  filter(month == 1, day == 1, dep_delay > 60)

# Multiple conditions: comma = AND, | = OR
flights |>
  filter(carrier %in% c("UA", "AA") | dep_delay < 0)

select — column selection

flights |> select(year, month, day, dep_delay, arr_delay)

# Helpers: starts_with, ends_with, contains, matches, where
flights |> select(starts_with("dep"), ends_with("delay"))
flights |> select(where(is.numeric))

# Rename while selecting:
flights |> select(departure_delay = dep_delay, arrival_delay = arr_delay)

mutate — adding or modifying columns

Equivalent to df[&#039;new<em>col&#039;] = ... but inside a pipeline, and you can chain multiple mutations referencing earlier ones:

flights |>
  mutate(
    gain        = dep_delay - arr_delay,
    gain_per_hr = gain / (air_time / 60),
    on_time     = arr_delay <= 0
  ) |>
  select(flight, gain, gain_per_hr, on_time)

summarise + groupby

Equivalent to pandas groupby().agg():

flights |>
  group_by(carrier) |>
  summarise(
    n_flights    = n(),
    mean_delay   = mean(arr_delay, na.rm = TRUE),
    pct_on_time  = mean(arr_delay <= 0, na.rm = TRUE)
  ) |>
  arrange(desc(mean_delay))

n() counts rows within each group. mean() on a logical vector computes the proportion of TRUE values — an extremely common idiom.

arrange — row ordering

flights |> arrange(year, month, day, desc(dep_delay))

Joins

dplyr's join family mirrors SQL (INNER JOIN, LEFT JOIN, etc.):

• inner<em>join(x, y, by = &quot;key&quot;) — keep rows with matches in both
• left</em>join(x, y, by = &quot;key&quot;) — keep all rows in x
• anti<em>join(x, y, by = &quot;key&quot;) — keep rows in x with NO match in y
• semi</em>join(x, y, by = &quot;key&quot;) — keep rows in x WITH a match, but don't add y's columns

airlines <- nycflights13::airlines
flights |>
  left_join(airlines, by = "carrier") |>
  select(flight, name, dep_delay) |>
  rename(airline = name)

For multi-column keys: by = c("origin" = "faa") when names differ between tables.

Window Functions and Grouped Mutate

A powerful dplyr pattern: use group<em>by() before mutate() instead of summarise() to compute group-level statistics while retaining individual rows:

flights |>
  group_by(carrier) |>
  mutate(
    delay_rank   = min_rank(desc(dep_delay)),  # rank within carrier
    mean_carrier = mean(dep_delay, na.rm = TRUE),
    above_avg    = dep_delay > mean_carrier
  ) |>
  ungroup()   # always ungroup when done to prevent downstream surprises

Common window functions: row</em>number(), min<em>rank(), dense</em>rank(), lag(), lead(), cumsum(), cummean().

Useful Helper: across()

across() applies a function to multiple columns without copy-pasting:

flights |>
  group_by(carrier) |>
  summarise(across(ends_with("delay"), mean, na.rm = TRUE))

# Apply multiple functions at once:
flights |>
  summarise(across(where(is.numeric),
                   list(mean = mean, sd = sd),
                   na.rm = TRUE))

This replaces the older summarise<em>at / summarise</em>if / summarise_all functions that you may see in older code.

Common Pitfalls

• Forgetting ungroup(): grouping persists through subsequent verbs in the same pipeline. Always ungroup() when the grouped computation is done.
• NA in filter: filter(x == NA) silently drops everything. Use is.na(x) or filter(!is.na(x)).
• = vs ==: Inside filter(), use == for equality. = is valid R there but assigns, not compares.
• Overwriting with mutate: mutate(col = ...) overwrites col in place — use a new name if you need both.

Tidy Data Principles

Hadley Wickham's tidy data framework defines a standard structure that most Tidyverse functions expect:

1. Each variable forms a column.
2. Each observation forms a row.
3. Each type of observational unit forms a table.

Most real-world data is messy. The two most common violations are wide data (multiple observations per row, encoded as separate columns) and long data that conflates different variables into a single column.

# Wide — one row per student, one column per exam
wide <- tibble(
  student = c("Alice", "Bob"),
  exam1   = c(88, 75),
  exam2   = c(92, 81),
  exam3   = c(79, 95)
)

# Tidy — one row per (student, exam) pair
long <- tidyr::pivot_longer(wide,
  cols      = starts_with("exam"),
  names_to  = "exam",
  values_to = "score"
)

pivotlonger and pivotwider

pivot<em>longer collapses many columns into key-value pairs (equivalent to pd.melt):

library(tidyr)

# names_prefix strips a common prefix from the new key column
long <- wide |>
  pivot_longer(
    cols         = exam1:exam3,
    names_to     = "exam",
    names_prefix = "exam",          # strip "exam" -> "1", "2", "3"
    values_to    = "score"
  ) |>
  mutate(exam = as.integer(exam))

pivot</em>wider is the inverse (equivalent to pd.pivot or pd.unstack):

# Reconstruct wide format
long |>
  pivot_wider(
    names_from  = exam,
    values_from = score,
    names_prefix = "exam"
  )

Advanced pivot: multiple value columns

When each measurement has multiple associated values, pivot<em>longer can handle them simultaneously via names</em>to = c(&quot;var&quot;, &quot;time&quot;) with names<em>sep or names</em>pattern:

df <- tibble(
  id      = 1:3,
  bp_t1   = c(120, 130, 115),
  bp_t2   = c(118, 128, 120),
  hr_t1   = c(70, 80, 65),
  hr_t2   = c(72, 78, 68)
)

df |>
  pivot_longer(
    cols         = -id,
    names_to     = c("metric", "time"),
    names_sep    = "_",
    values_to    = "value"
  )

Handling Nested and Missing Data

complete() makes implicit missing values explicit — crucial before plotting time series:

sales <- tibble(
  month   = c(1, 2, 4),   # March is missing!
  revenue = c(100, 150, 130)
)

sales |> complete(month = 1:4, fill = list(revenue = 0))
# Now month 3 appears with revenue = 0

fill() carries values forward or backward (LOCF / NOCB):

tibble(month = 1:4, category = c("A", NA, NA, "B")) |>
  fill(category, .direction = "down")   # propagate "A" downward

separate() and unite() split and join columns:

tibble(date_id = c("2024-01", "2024-02")) |>
  separate(date_id, into = c("year", "month"), sep = "-", convert = TRUE)

String Manipulation with stringr

stringr provides a consistent interface wrapping PCRE regex. All functions start with str_:

library(stringr)

x <- c("  Hello, World!  ", "foo@bar.com", "2024-06-04")

str_trim(x)                       # strip whitespace
str_to_lower(x)                   # lowercase
str_detect(x, "@")                # logical: contains @?
str_extract(x, "\\d{4}-\\d{2}-\\d{2}")  # extract ISO date
str_replace_all(x, "[aeiou]", "*")      # replace vowels
str_split(x[1], ",")             # split on comma -> list

For dates, lubridate is the go-to package:

library(lubridate)

ymd("2024-06-04")        # parse ISO date -> Date object
dmy("04/06/2024")        # day-month-year
now()                    # current datetime with timezone
ymd("2024-06-04") + days(30)
floor_date(now(), "month")       # first of current month

Nesting Data Frames

One of R's most powerful patterns is the list-column: a tibble column that contains lists of objects (including other tibbles). nest() groups rows into sub-tibbles:

library(dplyr)
library(tidyr)

by_species <- iris |>
  as_tibble() |>
  group_by(Species) |>
  nest()   # 'data' column contains a tibble per species

by_species
# A tibble: 3 x 2
#   Species    data
#   <fct>      <list>
# 1 setosa     <tibble [50 x 4]>
# 2 versicolor <tibble [50 x 4]>
# 3 virginica  <tibble [50 x 4]>

This nest-map-unnest workflow is the Tidyverse approach to split-apply-combine and is explored further in the purrr section.

Why purrr Instead of Loops?

Explicit for loops work in R but produce verbose, error-prone code and encourage thinking in steps rather than transformations. The purrr package provides a family of map<em>* functions — R's equivalent to Python's map(), itertools, and list comprehensions — that express "do this to each element" concisely and safely.

The key design principle: map always returns a list. Type-stable variants (map</em>dbl, map<em>chr, map</em>int, map<em>lgl) return atomic vectors and raise an error if any element has the wrong type — catching bugs that loops silently ignore.

library(purrr)

numbers <- list(a = 1:5, b = 10:15, c = 100:110)

map(numbers, mean)            # returns a list of means
map_dbl(numbers, mean)        # returns a named numeric vector
map_int(numbers, length)      # returns a named integer vector
map_chr(numbers, ~ paste0("n=", length(.x)))  # named character vector

The ~ (tilde) syntax creates an anonymous function (lambda). .x refers to the current element; .y is available in two-argument variants (map2).

The map Family

• map(.x, .f) — apply .f to each element of .x
• map2(.x, .y, .f) — apply .f to paired elements of .x and .y
• pmap(.l, .f) — apply .f to parallel elements of a list of vectors
• walk(.x, .f) — like map but called for side effects (printing, writing files); returns .x invisibly
• imap(.x, .f) — like map but passes the name/index as the second argument

# map2: compute weighted means
values  <- list(c(1,2,3), c(4,5,6))
weights <- list(c(1,1,2), c(2,2,1))
map2_dbl(values, weights, weighted.mean)
# [1] 2.25 4.60

# pmap: operate on multiple parallel columns as a list
params <- tibble(
  x    = c(1, 2, 3),
  mean = c(0, 5, 10),
  sd   = c(1, 2, 3)
)
pmap_dbl(params, ~ dnorm(..1, ..2, ..3))  # density at x given mean, sd

Predicate and Extraction Helpers

numbers <- list(1, "two", 3, "four", 5)

keep(numbers, is.numeric)         # list(1, 3, 5)
discard(numbers, is.numeric)      # list("two", "four")
every(numbers, is.numeric)        # FALSE
some(numbers, is.numeric)         # TRUE
detect(numbers, ~ .x > 2)        # 3  (first match)

# Deep extraction with map + pluck:
response <- list(
  list(user = list(name = "Alice", age = 30)),
  list(user = list(name = "Bob",   age = 25))
)
map_chr(response, ~ pluck(.x, "user", "name"))  # c("Alice", "Bob")

The Nest-Map-Unnest Pattern

The most powerful Tidyverse workflow combines tidyr::nest(), purrr::map(), and tidyr::unnest() to fit models or run computations per group without explicit loops:

library(dplyr)
library(tidyr)
library(purrr)
library(broom)

# Fit a linear model per species in the iris dataset
models <- iris |>
  as_tibble() |>
  group_by(Species) |>
  nest() |>
  mutate(
    fit     = map(data, ~ lm(Sepal.Length ~ Petal.Length, data = .x)),
    tidied  = map(fit, tidy),     # broom::tidy extracts coefficients
    glanced = map(fit, glance)    # broom::glance extracts model stats
  )

# Extract all coefficients into one tidy data frame:
models |>
  select(Species, tidied) |>
  unnest(tidied)

This pattern scales to hundreds of groups without changing a single line of code. The same structure works for cross-validation splits, bootstrap samples, or any per-group computation.

reduce and accumulate

reduce() folds a list into a single value, applying a binary function left-to-right — equivalent to Python's functools.reduce:

reduce(list(1, 2, 3, 4), `+`)         # 10
reduce(list(df1, df2, df3), left_join, by = "id")  # join a list of frames!
accumulate(1:5, `+`)                   # running totals: 1 3 6 10 15

The reduce(frames, left</em>join, by = &quot;id&quot;) pattern elegantly joins an arbitrary number of tables without nesting left_join calls.

Error Handling in Iterations

When one element fails, the entire map fails. Use safely() or possibly() wrappers to handle errors gracefully:

safe_log <- safely(log, otherwise = NA_real_)
results  <- map(list(10, -1, 0, 100), safe_log)

# Extract results and errors separately:
map_dbl(results, ~ .x$result %||% NA)
map_chr(results, ~ if (!is.null(.x$error)) .x$error$message else "ok")

possibly() is simpler when you only want the fallback value:

possibly_log <- possibly(log, otherwise = NA_real_)
map_dbl(list(10, -1, 0, 100), possibly_log)
# [1]  2.302585        NA      -Inf  4.605170

The Grammar of Graphics

ggplot2 implements Leland Wilkinson's Grammar of Graphics — a principled decomposition of a chart into independent components that can be combined freely. This is fundamentally different from Matplotlib's procedural API or Seaborn's chart-type functions.

Every ggplot2 plot is built from these layers:

• Data — a data frame (always tidy format)
• Aesthetics (aes()) — mappings from data columns to visual properties (x, y, color, size, shape, fill, alpha, linetype)
• Geometries (geom<em><em>) — the visual marks (points, lines, bars, boxes, ribbons...)
• Scales (scale</em></em>) — control how data values map to visual properties
• Facets (facet<em><em>) — small multiples splitting the plot by a variable
• Statistics (stat</em></em>) — computed transformations (binning, smoothing, summarizing)
• Coordinates (coord<em><em>) — the coordinate system (Cartesian, polar, flipped, map)
• Themes (theme</em></em>) — non-data ink (fonts, backgrounds, grid lines)

Building a Plot Layer by Layer

library(ggplot2)

# Start with data + mapping, add geom
ggplot(mtcars, aes(x = wt, y = mpg)) +
  geom_point()

# Add a smooth trend line with confidence band
ggplot(mtcars, aes(x = wt, y = mpg)) +
  geom_point(aes(color = factor(cyl)), size = 2) +
  geom_smooth(method = "lm", se = TRUE, color = "steelblue") +
  scale_color_brewer(palette = "Set1", name = "Cylinders") +
  labs(
    title    = "Fuel Efficiency vs. Weight",
    subtitle = "Linear fit by cylinder count",
    x        = "Weight (1000 lbs)",
    y        = "Miles per Gallon",
    caption  = "Source: Motor Trend, 1974"
  ) +
  theme_minimal(base_size = 13)

Notice: + rather than |> — ggplot2 uses + to add layers because it predates the pipe and its API is additive, not sequential.

Common Geoms

• geom<em>point() — scatter plot
• geom</em>line() — line chart (order matters: sorts by x)
• geom<em>bar(stat = &quot;count&quot;) / geom</em>col() — bar chart (col takes pre-computed heights)
• geom<em>histogram(bins = 30) — histogram
• geom</em>boxplot() — box-and-whisker
• geom<em>violin() — violin plot (richer than boxplot for multimodal distributions)
• geom</em>tile() — heatmap
• geom<em>ribbon(aes(ymin, ymax)) — confidence bands
• geom</em>text() / geom<em>label() — text annotations

Faceting for Small Multiples

Faceting is one of ggplot2's strongest features — it splits a plot by a categorical variable, keeping scales consistent:

ggplot(nycflights13::flights |> dplyr::sample_n(5000),
       aes(x = dep_delay, y = arr_delay)) +
  geom_point(alpha = 0.3, size = 0.8) +
  geom_abline(slope = 1, intercept = 0, color = "red", linetype = "dashed") +
  facet_wrap(~ carrier, ncol = 4) +
  coord_cartesian(xlim = c(-30, 120), ylim = c(-60, 120)) +
  theme_light()

facet</em>grid(rows ~ cols) creates a grid facet; facet<em>wrap(~ var) wraps into a specified number of columns.

Statistical Transformations

Many geoms implicitly apply a stat. You can override or use stats directly:

# stat_summary computes mean + CI and draws error bars
ggplot(iris, aes(x = Species, y = Sepal.Length)) +
  stat_summary(fun = mean, geom = "point", size = 4) +
  stat_summary(fun.data = mean_cl_boot, geom = "errorbar", width = 0.2)

Scales and Color

Scales control the mapping from data to aesthetics and are where most customization happens:

ggplot(economics, aes(x = date, y = unemploy / pop)) +
  geom_line(color = "#2c7bb6") +
  scale_x_date(date_labels = "%Y", date_breaks = "5 years") +
  scale_y_continuous(labels = scales::percent_format(accuracy = 0.1)) +
  labs(y = "Unemployment Rate", x = NULL)

Color scale guide:

• scale</em>color<em>brewer / scale</em>fill<em>brewer — ColorBrewer palettes (good for categorical)
• scale</em>color<em>viridis</em>c / <em>d — perceptually uniform, colorblind-safe
• scale</em>color<em>gradient(low, high) — two-color continuous gradient
• scale</em>color_gradient2(low, mid, high, midpoint) — diverging

Themes

# Built-in themes
theme_gray()     # default
theme_bw()       # white background, grey grid
theme_minimal()  # minimal chrome
theme_classic()  # no grid, like base R

# Fine-grained control via theme()
p + theme(
  axis.text.x   = element_text(angle = 45, hjust = 1),
  legend.position = "bottom",
  plot.title    = element_text(face = "bold", size = 16)
)

Saving Plots

ggsave("my_plot.png", plot = last_plot(), width = 8, height = 5, dpi = 300)
ggsave("my_plot.pdf", width = 8, height = 5)  # vector for publications

ggsave automatically infers format from the file extension and respects dpi for raster output.

Statistical Modeling in R

R's formula syntax y ~ x1 + x2 is a first-class language construct — the same expression that specifies a model structure is used consistently across lm, glm, lmer, survival::coxph, and hundreds of other modeling functions.

Linear Models

data(mtcars)
fit <- lm(mpg ~ wt + hp + factor(cyl), data = mtcars)
summary(fit)

summary(fit) prints coefficients, standard errors, t-statistics, p-values, and $R^2$. The formula factor(cyl) creates dummy variables on the fly.

Formula operators:

• y ~ x1 + x2 — main effects
• y ~ x1 * x2 — main effects plus interaction (expands to x1 + x2 + x1:x2)
• y ~ x1:x2 — interaction only
• y ~ . — all columns in data except y
• y ~ . - x1 — all except y and x1
• y ~ poly(x, 2) — orthogonal polynomial
• y ~ I(x^2) — I() escapes arithmetic inside formulas

Generalized Linear Models

# Logistic regression
birth_fit <- glm(low ~ age + lwt + smoke,
                 data   = MASS::birthwt,
                 family = binomial(link = "logit"))

# Poisson regression for counts
count_fit <- glm(n ~ offset(log(exposure)) + group,
                 family = poisson())

Tidy Model Output with broom

Base R's summary() output is S3 objects that are hard to work with programmatically. broom converts model objects into tidy tibbles:

library(broom)

tidy(fit)     # coefficients table as tibble
glance(fit)   # one-row model summary (R2, AIC, BIC, F-stat)
augment(fit)  # original data + fitted values, residuals, leverage

augment() is particularly powerful for diagnostics:

augment(fit) |>
  ggplot(aes(x = .fitted, y = .resid)) +
  geom_point(alpha = 0.5) +
  geom_hline(yintercept = 0, linetype = "dashed", color = "red") +
  labs(title = "Residuals vs Fitted", x = "Fitted Values", y = "Residuals")

Comparing Models

fit_base  <- lm(mpg ~ wt,          data = mtcars)
fit_full  <- lm(mpg ~ wt + hp + cyl, data = mtcars)

# Likelihood ratio test (nested models)
anova(fit_base, fit_full)

# AIC comparison
map_dfr(list(base = fit_base, full = fit_full),
        ~ glance(.x) |> select(r.squared, AIC, BIC),
        .id = "model")

R Markdown for Reproducible Research

R Markdown (.Rmd) documents weave R code, output, and narrative prose into a single source file that renders to HTML, PDF, Word, slides, or dashboards. This is the R equivalent of a Jupyter notebook, but with tighter integration of the document structure and more options for polished output.

Anatomy of an R Markdown Document

An .Rmd file has three parts:

1. YAML header (between --- delimiters):

---
title: "Analysis of Flight Delays"
author: "Your Name"
date: "`r Sys.Date()`"
output:
  html_document:
    toc: true
    toc_float: true
    theme: flatly
    code_folding: hide
---

2. Markdown prose — standard Markdown text with R expressions inline: ` r nrow(df) renders the value in the output.</p> <p><strong>3. Code chunks</strong>:</p> <p>

Inline R Expressions

Inline code makes prose self-updating — when data changes, the numbers in the text re-render automatically:

The dataset contains `r nrow(flights)` flights operated by
`r n_distinct(flights$carrier)` carriers. The mean departure
delay was `r round(mean(flights$dep_delay, na.rm = TRUE), 1)` minutes.

Rendering

rmarkdown::render("analysis.Rmd")               # HTML by default
rmarkdown::render("analysis.Rmd",
                  output_format = "pdf_document")  # requires LaTeX
rmarkdown::render("analysis.Rmd",
                  output_format = "word_document")

Or use the Knit button in RStudio. From the command line:

Rscript -e "rmarkdown::render('analysis.Rmd')"

Parameterized Reports

Declare parameters in the YAML header and pass different values to generate multiple reports from one template:

---
params:
  carrier: "UA"
  min_year: 2013
---

# In the body, reference params$carrier and params$min_year
filtered <- flights |>
  filter(carrier == params$carrier,
         year >= params$min_year)

# Render a report per carrier:
purrr::walk(
  c("UA", "AA", "DL"),
  ~ rmarkdown::render("report.Rmd",
                      params = list(carrier = .x),
                      output_file = paste0("report_", .x, ".html"))
)

Parameterized reports are a production-ready pattern for automated reporting pipelines.