How to delegate tar_combine() into a function?

[MarekGierlinski]

Help

• I understand and agree to https://books.ropensci.org/targets/help.html.

Description

I use tar_map() to create several targets and then combine them using tar_combine(). I want to create a column in the combined data frame containing a specified name (variable NAME below), not the target name. Hence, I created a little helper function br() to do the job. This code works fine and does the job:

tar_script({
  library(tarchetypes)

  sets <- tibble::tibble(
    NAME = c("A", "B", "C"),
    CYL = c(4, 6, 8)
  )

  mt_map <- tar_map(
    values = sets,
    names = NAME,

    tar_plan(
      mt = mtcars |> dplyr::filter(cyl == CYL),
      md = mt |> dplyr::summarise(mean = mean(disp))
    )  
  )

  br <- function(..., suffix = "") {
    dots <- list(...)
    names(dots) <- stringr::str_remove(names(dots), paste0(suffix, "_"))
    dplyr::bind_rows(dots, .id = "set")
  }

  combined <- tar_plan(
    tar_combine(cm, mt_map[["mt"]], command = br(!!!.x, suffix = "mt"))
  )

  c(mt_map, combined)
})

tar_make()

However, this is not the most elegant solution. In the real code I'm going to have dozens of targets in the combined plan. It just looks clunky, with the target base name ("mt") repeated twice in each tar_combine() call.

So, I wanted to move tar_combine() into a separate function where I can control things better and have a cleaner tar_plan(). Here is my attempt:

tar_script({
  library(tarchetypes)

  sets <- tibble::tibble(
    NAME = c("A", "B", "C"),
    CYL = c(4, 6, 8)
  )

  mt_map <- tar_map(
    values = sets,
    names = NAME,

    tar_plan(
      mt = mtcars |> dplyr::filter(cyl == CYL),
      md = mt |> dplyr::summarise(mean = mean(disp))
    )  
  )

  br <- function(..., suffix = "") {
    dots <- list(...)
    names(dots) <- stringr::str_remove(names(dots), paste0(suffix, "_"))
    dplyr::bind_rows(dots, .id = "set")
  }

  my_combine <- function(name, tmap, suffix) {
    tar_combine(
      name = name,
      tmap[[suffix]],
      command = br(!!!.x, suffix = suffix)
    )
  }

  combined <- tar_plan(
    my_combine(cm, mt_map, suffix = "mt")
  )

  c(mt_map, combined)
})

tar_make()

This does not work. It crashes with error

+ name dispatched                            
✖ name errored
✖ errored pipeline [110ms, 0 completed, 5 skipped]
Error:
! Error in tar_make():
  object 'suffix' not found

It is trying to create a target called name instead of cm. The target name does not permeate from the function my_combine() up to my tar_plan(). Using {{ name }} in the function my_combine() does not work.

I tried forcing a new target name:

combined <- tar_plan(
  new_cm = my_combine(cm, mt_map, suffix = "mt")
)

but this creates an unevaluated target new_cm.

It seems to be a simple matter of encapsulating a bit of code in a function, but because of the way targets handle target names I cannot get it to work.

[wlandau]

It's usually much easier to supply the metadata in each branch and rely on defaults for tar_combine(). This is a good pattern for both static and dynamic branching, and debugging tends to be easier because each branch can tell you exactly where it came from.

library(targets)
library(tarchetypes)

sets <- tibble::tibble(
  NAME = c("A", "B", "C"),
  CYL = c(4, 6, 8)
)

mt_map <- tar_map(
  values = sets,
  names = NAME,

  tar_plan(
    mt = mtcars |> dplyr::filter(cyl == CYL),
    md = mt |>
      dplyr::summarise(mean = mean(disp)) |>
      mutate(set = NAME) # Supply the name here
  )
)

combined <- tar_combine(cm, mt_map[["mt"]]) # Use defaults for tar_combine().

list(mt_map, combined)

[MarekGierlinski]

Thank you for your answer. Yes, I've been doing this too, though this requires repetition of mutate(set = NAME) in many lines of tar_plan(). I'm guessing there is no simple an elegant way of putting tar_combine() in a function as in my attempts?

[wlandau]

Yes, I've been doing this too, though this requires repetition of mutate(set = NAME) in many lines of tar_plan().

Hooks like tarchetypes::tar_hook_outer() can add commands in bulk, and tarchetypes::tar_map() can condense even more repetition than that.

I'm guessing there is no simple an elegant way of putting tar_combine() in a function as in my attempts?

It's possible, but the metaprogramming is usually not worth the trouble.