Tweet
Tweet

Slide 1

Slide 1 text

 @jennybc  @JennyBryan Jennifer Bryan rstd.io/tidy-eval-context

Slide 2

Slide 2 text

rstd.io/tidy-eval-context

Slide 3

Slide 3 text

This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License. To view a copy of this license, visit 
 http://creativecommons.org/licenses/by-sa/4.0/

Slide 4

Slide 4 text

What is tidy evaluation?

Slide 5

Slide 5 text

What is tidy evaluation? Is it going to kill you or us?

Slide 6

Slide 6 text

No content

Slide 7

Slide 7 text

‼ ‼

Slide 8

Slide 8 text

hold on, wait ... ✋

Slide 9

Slide 9 text

May have more bang bang for the buck than learning tidy eval: 1. How to write functions 2. Domain-specific tooling (maps, time series, etc.) 3. Lists, list-columns, nesting, unnesting 4. Functional programming with purrr 5. Scoped dplyr verbs, e.g. mutate_at()

Slide 10

Slide 10 text

What is tidy evaluation?

Slide 11

Slide 11 text

Tidy eval is: a toolkit for metaprogramming in R. Is something about the toolkit tidy? Yeah, I think so! But also ...

Slide 12

Slide 12 text

The tidyverse makes heavy use of metaprogramming, behind the scenes. Tidy eval powers all of that.

Slide 13

Slide 13 text

library(tidyverse) starwars %>% filter(homeworld == "Tatooine") %>% arrange(height) %>% select(name, ends_with("color")) ggplot(mpg, aes(displ, hwy, colour = class)) + geom_point()

Slide 14

Slide 14 text

metaprogramming ≈ nonstandard evaluation (NSE) ≈ unquoted variable names * this is technically WRONG but useful

Slide 15

Slide 15 text

To evaluate an expression, you search environments for name-value bindings. Nonstandard evaluation means you might: - modify the expression first - modify the chain of searched environments

Slide 16

Slide 16 text

Functions that accept unquoted variable names (+ an associated data frame) must implement NSE. If you wrap such a function, you're obligated to deal with the NSE.

Slide 17

Slide 17 text

If you make direct specification of variable names extremely easy ... it makes indirect specification harder. Examples of indirect specification: - names stored in an object - names passed as function arguments

Slide 18

Slide 18 text

Is this challenge unique to the tidyverse? No, it's present in base R as well.

Slide 19

Slide 19 text

lm(lifeExp ~ year, weights = pop, data = gapminder) subset(gapminder, country == "Chad", select = year:pop) transform(gapminder, GDP = gdpPercap * pop) with(gapminder, lifeExp[country == "Chad" & year < 1980])

Slide 20

Slide 20 text

⚠ Warning ⚠ This is a convenience function intended for use interactively. For programming it is better to use the standard subsetting functions like [, and in particular the non- standard evaluation of argument subset can have unanticipated consequences. ?subset, ?transform, ?with

Slide 21

Slide 21 text

lm(lifeExp ~ poly(I(year - 1952), degree = 2)) life expectancy = β0 + β1 * year + β2 * year2 + ε

Slide 22

Slide 22 text

Want to fit model to each Gapminder country? 1. Wrap lm() in a function. 2. Drop into an iterative machine. fit_fun <- function(df) { lm(lifeExp ~ poly(I(year - 1952), degree = 2), data = df) } by(gapminder, gapminder$country, fit_fun)

Slide 23

Slide 23 text

fit_fun <- function(df) { lm(lifeExp ~ poly(I(year - 1952), degree = 2), data = df) } by(gapminder, gapminder$country, fit_fun) #> gapminder$country: Afghanistan #> #> Call: #> lm(formula = lifeExp ~ poly(I(year - 1952), degree = 2), data = df) #> #> Coefficients: #> (Intercept) 1 2 #> 37.479 16.462 -3.445 #> -------------------------------------------------------- #> gapminder$country: Albania #> #> and so on ...

Slide 24

Slide 24 text

Y = β0 + β1 * X + β2 * X2 + ε fit_fun <- function(df, y, x) { lm(y ~ poly(x, degree = 2), data = df) }

Slide 25

Slide 25 text

library(gapminder) nope <- function(df, y, x) { lm(y ~ poly(x, degree = 2), data = df) } ## will this work? nope(gapminder, lifeExp, year) #> Error in eval(predvars, data, env): #> object 'year' not found ## do quotes help? nope(gapminder, "lifeExp", "year") #> Error in poly(x, degree = 2): 'degree' #> must be less than number of unique points

Slide 26

Slide 26 text

wow <- function(df, y, x) { lm_formula <- substitute( y ~ poly(x, degree), list(y = substitute(y), x = substitute(x), degree = 2) ) eval(lm(lm_formula, data = df)) } This works, but

Slide 27

Slide 27 text

wow(gapminder, y = lifeExp, x = year - 1952) wow(gapminder, y = gdpPercap, x = year - 1952) wow(gapminder, y = lifeExp, x = gdpPercap) Payoff: wow() is pleasant to use!

Slide 28

Slide 28 text

In base R, programming around NSE-using functions has been explicitly or implicitly discouraged.

Slide 29

Slide 29 text

The messy eval era ggplot2::aes_string() vs. aes() dplyr::select_() vs. select() etc. Not predictable for users Not pleasant to maintain

Slide 30

Slide 30 text

Good news: The tidyverse prioritizes usability, such as a data mask and unquoted variable names. Bad news: Programming around this is harder. Good news: We provide ourselves & you a toolkit for this.

Slide 31

Slide 31 text

rlang.r-lib.org rlang provides the toolkit but most people don't need to make direct use of rlang

Slide 32

Slide 32 text

What do you want to do? I'll tell you how much tidy eval you need to know.

Slide 33

Slide 33 text

You want to: Use existing tidyverse functions to analyze data. You need to know this much tidy eval: None. Congrats! Rock on.

Slide 34

Slide 34 text

You want to: Write simple functions to reduce duplication. You need to know this much tidy eval: Perhaps none! "Pass the dots". You do not need rlang.

Slide 35

Slide 35 text

grouped_height <- function(df, ...) { df %>% group_by(...) %>% summarise(avg_height = mean(height, na.rm = TRUE)) }

Slide 36

Slide 36 text

grouped_height(starwars, homeworld) #> # A tibble: 49 x 2 #> homeworld avg_height #> #> 1 139. #> 2 Alderaan 176. #> ... grouped_height(starwars, species) #> # A tibble: 38 x 2 #> species avg_height #> #> 1 160 #> 2 Aleena 79 #> ...

Slide 37

Slide 37 text

You want to: Write simple functions to reduce duplication. You need to know this much tidy eval: enquo() and !! dplyr, ggplot2, and tidyr expose this. You do not need rlang.

Slide 38

Slide 38 text

grouped_mean <- function(df, group_var, summary_var) { group_var <- enquo(group_var) summary_var <- enquo(summary_var) df %>% group_by(!!group_var) %>% summarise(mean = mean(!!summary_var, na.rm = TRUE)) }

Slide 39

Slide 39 text

grouped_mean(starwars, homeworld, height) #> # A tibble: 49 x 2 #> homeworld mean #> #> 1 139. #> 2 Alderaan 176. #> 3 ... grouped_mean(starwars, homeworld, mass) #> # A tibble: 49 x 2 #> homeworld mean #> #> 1 82 #> 2 Alderaan 64 #> 3 ...

Slide 40

Slide 40 text

You want to: Write functions that make names from user input. You need to know this much more tidy eval: := dplyr, ggplot2, and tidyr expose this. You do not need rlang.

Slide 41

Slide 41 text

You want to: Compute on expressions & manipulate environments. You need to know this much more tidy eval: You do need to understand the theory. You need rlang.

Slide 42

Slide 42 text

Helpful resources written by others: Standard nonstandard evaluation rules Thomas Lumley (2003) http://developer.r-project.org/nonstandard-eval.pdf Scoping Rules and NSE Thomas Mailund https://mailund.dk/posts/scoping-rules-and-nse/ Yet Another Introduction to Tidy Eval Hiroaki Yutani https://speakerdeck.com/yutannihilation/yet-another-introduction-to-tidyeval

Slide 43

Slide 43 text

Helpful resources from tidy eval creators: Metaprogramming chapters of Advanced R, 2nd edition Hadley Wickham https://adv-r.hadley.nz/introduction-16.html Tidy evaluation Lionel Henry https://tidyeval.tidyverse.org RStudio community thread https://community.rstudio.com/t/interesting-tidy-eval-use-cases

Slide 44

Slide 44 text

 @jennybc  @JennyBryan Jennifer Bryan rstd.io/tidy-eval-context