Is there a way to use do.call without explicitly providing arguments

Question

Part of a custom function I am trying to create allows the user to provide a function as a parameter. For example

#Custom function
result <- function(.func){
  do.call(.func, list(x,y))
}

#Data
x <- 1:2
y <- 0:1

#Call function
result(.func = function(x,y){ sum(x, y) })

However, the code above assumes that the user is providing a function with arguments x and y. Is there a way to use do.call (or something similar) so that the user can provide a function with different arguments? I think that the correct solution might be along the lines of:

#Custom function
result <- function(.func){
  do.call(.func, formals(.func))
}

#Data
m <- 1:3
n <- 0:2
x <- 1:2
y <- 0:1
z <- c(4,6)

#Call function
result(.func = function(m,n){ sum(m, n) })
result(.func = function(x,y,z){ sum(x,y,z) })

But this is not it.

Answer 1

1) Use formals/names/mget to get the values in a list. An optional argument, envir, will allow the user to specify the environment that the variables are located in so it knows where to look. The default if not specified is the parent frame, i.e. the caller.

result1 <- function(.func, envir = parent.frame()) {
  do.call(.func, mget(names(formals(.func)), envir))
}

m <- 1:3
n <- 0:2
x <- 1:2
y <- 0:1
z <- c(4,6)

result1(.func = function(m,n) sum(m, n) )
## [1] 9

result1(.func = function(x,y,z) sum(x,y,z) )
## [1] 14

result1(function(Time, demand) Time + demand, list2env(BOD))
## [1]  9.3 12.3 22.0 20.0 20.6 26.8

1a) Another possibility is to evaluate the body. This also works if envir is specified as a data frame whose columns are to be looked up.

result1a <- function(.func, envir = parent.frame()) {
  eval(body(.func), envir)
}

result1a(.func = function(m,n) sum(m, n) )
## [1] 9

result1a(.func = function(x,y,z) sum(x,y,z) )
## [1] 14

result1a(function(Time, demand) Time + demand, BOD)
## [1]  9.3 12.3 22.0 20.0 20.6 26.8

2) Another design which is even simpler is to provide a one-sided formula interface. Formulas have environments so we can use that to look up the variables.

result2 <- function(fo, envir = environment(fo)) eval(fo[[2]], envir)

result2(~ sum(m, n))
## [1] 9

result2(~ sum(x,y,z))
## [1] 14

result2(~ Time + demand, BOD)
## [1]  9.3 12.3 22.0 20.0 20.6 26.8

3) Even simpler yet is to just pass the result of the computation as an argument.

result3 <- function(x) x

result3(sum(m, n))
## [1] 9

result3(sum(x,y,z))
## [1] 14

result3(with(BOD, Time + demand))
## [1]  9.3 12.3 22.0 20.0 20.6 26.8

Answer 2

Here is how I would do it based on your clarifying comments.

Basically since you say your function will take a data.frame as input, the function you are asking for essentially just reverses the order of arguments you pass to do.call()... which takes a function, then a list of arguments. A data.frame is just a special form of list where all elements (columns) are vectors of equal length (number of rows)

result <- function(.data, .func) {
  # .data is a data.frame, which is a list of argument vectors of equal length
  do.call(.func, .data)
}
result(data.frame(a=1, b=1:5), function(a, b) a * b)

result(data.frame(c=1:10, d=1:10), function(c, d) c * d)

Answer 3

You could also use ..., but like the other responses, I don't quite see the value, or perhaps I don't fully understand the use-case.

result <- function(.func, ...){
  do.call(.func, list(...))
}

Create function

f1 <- function(a,b) sum(a,b)

Pass f1 and values to result()

result(f1, m,n)

Output:

[1] 9

Answer 4

This seems like a bit of a pointless function, since the examples in your question imply that what you are trying to do is evaluate the body of the passed function using variables in the calling environment. You can certainly do this easily enough:

result <- function(.func){
  eval(body(.func), envir = parent.frame())
}

This gives the expected results from your examples:

x <- 1:2
y <- 0:1

result(.func = function(x,y){ sum(x, y) })
#> [1] 4

and

m <- 1:3
n <- 0:2
x <- 1:2
y <- 0:1
z <- c(4,6)

result(.func = function(m,n){ sum(m, n) })
#> [1] 9
result(.func = function(x,y,z){ sum(x,y,z) })
#> [1] 14

But note that, when the user types:

result(.func = function(x,y){ ...user code... })

They get the same result they would already get if they didn't use your function and simply typed

...user code....

You could argue that it would be helpful with a pre-existing function like mean.default:

x <- 1:10
na.rm <- TRUE
trim <- 0
result(mean.default)
#> [1] 5.5

But this means users have to name their variables as the parameters being passed to the function, and this is just a less convenient way of calling the function.

It might be useful if you could demonstrate a use case where what you are proposing doesn't make the user's code longer or more complex.

Answer 5

This works.

#Custom function
result <- function(.func){
  do.call(.func, lapply(formalArgs(.func), as.name))
}

#Data
m <- 1:3
n <- 0:2
x <- 1:2
y <- 0:1
z <- c(4,6)

#Call function
result(.func = function(m,n){ sum(m, n) })
result(.func = function(x,y,z){ sum(x,y,z) })