Pass a data.frame column name to a function?

Question

I'm trying to write a function to accept a data.frame (`x`) and a `column` from it. The function performs some calculations on x and later returns another data.frame. I'm stuck on the best-practices method to pass the column name to the function.The two minimal examples `fun1` and `fun2` below produce the desired result, being able to perform operations on `x$column`, using `max()` as an example. However, both rely on the seemingly (at least to me) inelegant 1. call to `substitute()` and possibly `eval()` 2. the need to pass the column name as a character vector. <!--> fun1 <- function(x, column){ do.call("max", list(substitute(x[a], list(a = column)))) } fun2 <- function(x, column){ max(eval((substitute(x[a], list(a = column))))) } df <- data.frame(B = rnorm(10)) fun1(df, "B") fun2(df, "B")I would like to be able to call the function as `fun(df, B)`, for example. Other options I have considered but have not tried: - Pass `column` as an integer of the column number. I think this would avoid `substitute()`. Ideally, the function could accept either. - `with(x, get(column))`, but, even if it works, I think this would still require `substitute` - Make use of `formula()` and `match.call()`, neither of which I have much experience with.*Subquestion*: Is `do.call()` preferred over `eval()`?

Answer 1

Quasiquotation

This is a metaprogramming^[1] question, where we manipulate R code itself as data. Quasiquotation^[2] is a handy way to do this, as shown below.

Here we capture the symbol for the column argument, using the enquo() function^[3]. Then we "inject" it into our code, using the special !! operator^[4].

# Covers basic quasiquotation.

library(dplyr)

# Example of injecting the column argument.

fun_inject <- function(x, column) {

# Capture the argument: B

col_arg <- enquo(column)

# Inject it: select(x, B)

select(x, !!col_arg)

}

fun_inject(df, B)

#> B

#> 1 1.23381453

#> 2 1.63732230

#> 3 -0.63244492

#> 4 0.81659294

#> 5 0.36073943

#> 6 -0.58101952

#> 7 1.67675010

#> 8 0.43765178

#> 9 0.89076884

#> 10 -0.01612531

A shortcut is to "embrace" it immediately, using the {{ operator^[5].

# Example of embracing the column argument.

fun_embrace <- function(x, column) {

select(x, {{ column }})

}

fun_embrace(df, B)

#> B

#> 1 1.23381453

#> 2 1.63732230

#> 3 -0.63244492

#> 4 0.81659294

#> 5 0.36073943

#> 6 -0.58101952

#> 7 1.67675010

#> 8 0.43765178

#> 9 0.89076884

#> 10 -0.01612531

You may even do this with several arguments at once, using the special !!! operator^[6].

Your Case

Many tidyverse^[7] functions like dplyr^[8] support quasiquotation automatically...but most functions like max() do not. When working with the latter, you'll need help from the rlang library^[9].

Your best bet is to create your code using the expr() function^[10]. Then execute it using the eval_tidy() function^[11], which treats the column from your dataset as a regular variable.

# Advanced quasiquotation.

library(rlang)

# Example of tidy evaluation.

fun_eval <- function(x, column) {

eval_tidy(

# Inject the argument: max(B)

expr(

max({{ column }})

),

# Execute in the context of your data.

data = x

)

}

fun_eval(df, B)

#> [1] 1.67675

The inject() function^[12] is an alternative, where you can omit expr(). But this can be tricky when using a dataset like yours, whose columns you wish to treat as variables.

Bibliography

1. https://adv-r.hadley.nz/metaprogramming
2. https://adv-r.hadley.nz/quasiquotation
3. https://rlang.r-lib.org/reference/enquo
4. https://rlang.r-lib.org/reference/injection-operator
5. https://rlang.r-lib.org/reference/embrace-operator
6. https://rlang.r-lib.org/reference/splice-operator
7. https://tidyverse.org
8. https://dplyr.tidyverse.org
9. https://rlang.r-lib.org
10. https://rlang.r-lib.org/reference/expr
11. https://rlang.r-lib.org/reference/eval_tidy
12. https://rlang.r-lib.org/reference/inject