将R中的任意函数列表组合成新函数[元编程]

Question

I want to take arbitrary list of functions that each take one argument, and turn them into one big function that runs each constituent function, one after the other, in order.

For example, let's look at three functions ( f , g , h ) that take a single argument. I want to supply them as arguments to my function-combiner like so:

function_maker(f,g,h)

and have it output the following function:

function(x) {
  f(x)
  g(x)
  h(x)
}

How would one do that? The functions supplied as arguments don't "interact" with each other, I just want them to run sequentially with the final value returned by the newly-made function being whatever would be returned from evaluating them in that sequence.

My primary worry is keeping all the environments, etc. correct, so that it the newly-made function will work in whichever environment it's called.

This is what I have so far, but I suspect that it's pretty fragile:

f <- function(x) {
  print("this is f")
  x + 2
}
g <- function(x) {
  print("this is g")
  x + 4
}
h <- function(x) {
  print("this is h")
  x + 9
}

function_maker <- function(...) {
  l <- rlang::enexprs(...) %>%
    purrr::map(~substitute(zzzz(cond), c(zzzz=.)))
  e <- rlang::expr({!!!l})
  e <- rlang::expr(function(cond) !!e)
  rlang::eval_tidy(e)
}

fgh <- function_maker(f,g,h)
body(fgh)
fgh(2)

Answer 1

This seems to do the job:

function_maker <- function(...) {
  ret  <- function(x) {}
  for(f in list(...)) {
    n <- length(body(ret))
    body(ret)[(n+1):(n + length(body(f)) - 1)] <- body(f)[-1]
  }
  ret
}

Result:

> function_maker(f, g, h)
function (x)
{
    print("this is f")
    x + 2
    print("this is g")
    x + 4
    print("this is h")
    x + 9
}

---

Alternatively something simpler:

function_maker <- function(...) {
  calls <- mapply(function(x) paste0(x, "(x)"), as.list(substitute(list(...)))[-1])
  as.call(c(as.name("{"), parse(text=calls)))
}

Which results in:

> function_maker(f,g,h)
{
    f(x)
    g(x)
    h(x)
}