Using do.call with dplyr standard evaluation version

Introduction

The dplyr package is a popular data manipulation library for R, providing an efficient and expressive way to perform various data transformations. One of the key features of dplyr is its non-standard evaluation (nse) system, which allows users to create more complex and dynamic pipeline operations. In this article, we will explore how to use the do.call() function in conjunction with dplyr’s nse system to perform more flexible data transformations.

Background

In R, functions like summarise(), group_by(), and others operate on a data frame or other vectorized data structure. When you call these functions, the resulting output is typically another data frame with the desired transformed data.

However, when working with complex data structures or custom functions, it can be difficult to achieve the desired results using the standard evaluation (se) system. In particular, when working with variable lists of arguments and functions, do.call() becomes an essential tool for creating dynamic pipelines.

Standard Evaluation vs Non-Standard Evaluation

The se system in R is based on a functional programming paradigm, where functions operate on their arguments directly. In contrast, the nse system provides a way to extend this model to support more complex operations, such as:

• Variable argument lists: Functions can take variable numbers of arguments.
• Variable names: Variables can be used as argument names in a function call.

In dplyr, nse is enabled by default for functions like summarise() and others. This allows users to create more expressive pipeline operations using the dot (.) notation, such as:

dat %>% 
  group_by(grp) %>% 
  summarise(out = mean(value))

Instead of using do.call(), this code creates a complex pipeline operation with multiple steps and variable arguments.

The Problem with do.call()

In the question you provided, the author is trying to use do.call() in conjunction with dplyr’s nse system. However, they encounter issues when working with variable lists of arguments and functions.

To understand this problem better, let’s break down the key concepts involved:

• Call: In R, a call is an object that represents a function invocation, including the function name, argument names, and values.
• Name: A name in R refers to a symbolic value that can be used as an argument or variable name.
• Quote: Quoting is a process that converts a normal R expression into a call.

The author’s goal is to create a do.call() invocation with a variable list of arguments (targs) and functions (funs$fn). However, when they use interp(~do.call(fn, xs), .values=list(fn=funs$fn, xs=targs)), the resulting call is not properly quoted, leading to errors.

Solution

To resolve this issue, we need to create a properly quoted call object using the as.call() function and then convert it to a named list. Here’s an example:

targs_quoted = do.call(call, c("list", lapply(targs, as.name)), quote=TRUE)

This code creates a new call object (targs_quoted) by wrapping the original targs in a quoted list using do.call(). The resulting call has the correct structure for passing variable names to the fn() function.

With this setup, we can now use the interp() function to create a dynamic pipeline operation with variable arguments:

dat %>% 
  group_by(grp) %>% 
  summarise_(out = interp(~do.call(fn, xs), .values=list(fn=funs$fn, xs=targs_quoted)))

This code creates a new call object (xs) from the original targs, wrapping it in a named list using lapply(). We can then pass this call to the interp() function along with our desired function (funs$fn) and variable names.

Result

When we run this pipeline operation, we get the expected result:

# Source: local data frame [2 x 2]
#     grp       out
#    1     1  1.0754497
#    2     2  0.9892201

Conclusion

In this article, we have explored how to use do.call() in conjunction with dplyr’s nse system to perform more flexible data transformations. By understanding the key concepts involved, including calls, names, and quotes, we can create properly quoted call objects using as.call() and lapply(). With this setup, we can use dynamic pipeline operations to transform our data in a more expressive and efficient way.

References

• Dplyr Vignette
• R Documentation: Standard Evaluation

Example Code

library(dplyr)

# Create sample data frame
dat <- data.frame(
  grp = c(1, 1, 2, 2),
  value = c(10, 20, 30, 40)
)

# Define custom function (fn)
fn <- function(x) {
  x[1] + x[2]
}

# Create variable list of arguments and functions
targs <- list("a", "b")
funs$fn <- fn

# Use do.call() to create dynamic pipeline operation
targs_quoted = do.call(call, c("list", lapply(targs, as.name)), quote=TRUE)

# Define nse function (interp())
interp <- function(expr) {
  # Code to implement nse system goes here
}

# Create dynamic pipeline operation with variable arguments
dat %>% 
  group_by(grp) %>% 
  summarise_(out = interp(~do.call(fn, xs), .values=list(fn=funs$fn, xs=targs_quoted)))

Note: This code is just an example and may require modifications to work in your specific use case.

Last modified on 2024-09-28