Do we have to store "mapped" targets together in the same targets chunk with the Target Markdown

[33Vito]

Not sure if it's a bug or feature. I realise that if two targets are "mapped", they have to be in the same targets chunk for it to work in interactive mode.

Example:

This works in both interactive and non-interactive mode:

```{targets combined}
list(
  tar_target(raw_data_combined, mtcars %>% group_by(cyl) %>% tar_group(), iteration = "group"),
  tar_target(count_row_combined, nrow(mtcars), pattern = map(raw_data))
)

This only works in non-interactive mode:

```{targets raw-data}
tar_target(raw_data, mtcars %>% group_by(cyl) %>% tar_group(), 
           iteration = "group")

```{targets count-row}
tar_target(count_row, nrow(mtcars), pattern = map(raw_data))

When I run it interactively in the Rmarkdown interface, the following error occur:

Error: Target count_row tried to branch over raw_data, which is illegal. Patterns must only branch over explicitly declared targets in the pipeline. Stems and patterns are fine, but you cannot branch over branches or global objects. Also, if you branch over a target with format = "file", then that target must also be a pattern.

Anyone has experienced this?

[wlandau]

This is a limitation. Interactive mode deliberately runs only the part of the pipeline inside the chunk, independently of other chunks. This helps write the R Markdown modularly and break down the pipeline into small pieces that are quick to run in a testing/prototyping scenario. The tradeoff, as you have seen, is that a chunk might not include upstream targets that dynamic targets depend on for branching. I have thought about this, and I do not think there is a good solution from a development point of view. It would either require a {targets} code chunk to be aware of other {targets} code chunks, or it would require allowing dynamic targets to map over non-targets, neither of which is feasible.

[33Vito]

Thanks, Will. I can understand the design trade-off here. I realised that I can actually run the code by commenting out the line of pattern, because I always save my input/output in list columns in a data.frame, it will just run without the definition of patterns. I only need pattern for parallel processing with tar_make_future(), so this actually fit nicely to my workflow. Thanks again for this great package!

[wlandau]

Hmm... it helps to know you don't mind commenting out code when you toggle interactive/noninteractive mode. I would imagine other users feel the same way, so in the development version I just added new functions tar_interactive() and tar_noninteractive() to only run code if interactive mode is (de)activated. So you could write something like this:

```{targets count-row}
list(
  tar_interactive(tar_target(raw_data, mtcars)),
  tar_target(count_row, nrow(raw_data), pattern = map(raw_data))
)
```

In interactive mode, raw_data is a test dataset defined in the chunk. In non-interactive mode, raw_data is not set to mtcars and is assumed to be defined elsewhere.

[33Vito]

That's perfect！