Why does do.call work in tar_target, but not in a target factory?

[nsheff]

I'm trying to write a target factory that will produce a target for an arbitrary function call and list of arguments, which are other targets. Here's a complete working example _targets.R that explains the question:

#_targets.R
library(targets)
generate_some_data = function() {
	rnorm(100)
}

# target factory
load_custom = function(tname, func, args) {
  l = as.list(args)
  command_data = substitute(do.call(func, args), env=list(args=lapply(l, as.symbol), 
      func=as.symbol(func)))
  tar_target_raw(tname, command_data)
}

list(
	tar_target(tar1, generate_some_data()),
	tar_target(tar2, generate_some_data()),
	tar_target(tar3, sum(tar1, tar2)),
	tar_target(tar4, do.call(sum, list(tar1, tar2))), 
	load_custom("tar5", "sum", list("tar1", "tar2"))
)

In this example, the creation of tar4 and tar5 create the exact same tar_stem object, with a command of do.call(sum, list(tar1, tar2). And tar4 works correctly, building this target with inputs of tar1 and tar2, so it has correctly recognized the dependencies. But the call through the target factory (load_custom) fails:

tar_make()
● run target tar5
✖ error target tar5
Error : object 'tar1' not found

This indicates that it is not correctly identifying tar1 as a target dependency. I am confused as to why tar_target(tar4, do.call(sum, list(tar1, tar2))) works, but generating the exact same target from a target factory fails.

[wlandau]

tar5 is disconnected from the graph because part of the R command is actually a list.

View(load_custom("tar5", "sum", list("tar1", "tar2"))$command$expr)

To avoid this problem, I would create an expression representation of args instead of inserting args directly via substitute(). Elements of env should be symbols or expressions. The following works for me:

load_custom = function(tname, func, args) {
  args_expr = as.call(c(as.symbol("list"), lapply(args, as.symbol)))
  command_data = substitute(
    do.call(func, args),
    env = list(args = args_expr, func = as.symbol(func))
  )
  tar_target_raw(tname, command_data)
}

[nsheff]

Thanks! that worked for me. I ended up tweaking it a bit so that you can pass some symbols and some of other types and this is what I ended up with:

load_custom = function(tname, func, argnames, argvals, argtypes) {
  l = as.list(argvals)
  names(l) = argnames
  l[argtypes == "symbol"] = lapply(l[argtypes == "symbol"], as.symbol)
  l[argtypes == "numeric"] = lapply(l[argtypes == "numeric"], as.numeric) 
  args_expr = as.call(c(as.symbol("list"), l))
  command_data = substitute(
    do.call(func, args),
    env = list(args = args_expr, func = as.symbol(func))
  )
  tar_target_raw(tname, command_data)
}

I think I will integrating this into a new csv targetopia package, as I mentioned here: databio/unitar#4