Targets Pipelines

Complex targets Pipelines

Branching creates multiple targets from a single definition. Choose your approach based on when iterations are known and what naming you need.

Quick Reference

| Task | Approach | Key Function/Pattern | |------|----------|---------------------| | Variants from known parameters | Static | tarchetypes::tar_map() | | Aggregate static variants | Static | tarchetypes::tar_combine() | | Runtime-determined iterations | Dynamic | pattern = map(x) | | All combinations (cartesian) | Dynamic | pattern = cross(x, y) | | Batched simulation reps | Dynamic | tarchetypes::tar_rep() | | Static variants + batched reps | Hybrid | tarchetypes::tar_map_rep() | | Branch over row groups | Dynamic | tarchetypes::tar_group_by() | | Reusable multi-target pattern | Factory | Custom function + tar_target_raw() |

Decision Tree

Need multiple similar targets?
│
├─ NO ──► Single target, or consider a target factory
│         for reusable patterns
│
└─ YES ─► Iterations known before tar_make()?
          │
          ├─ NO ──► DYNAMIC BRANCHING
          │         pattern = map() / cross()
          │         → topic-dynamic-branching.md
          │
          └─ YES ─► Need friendly target names in DAG?
                    │
                    ├─ YES ──► STATIC BRANCHING
                    │          tarchetypes::tar_map()
                    │          → topic-static-branching.md
                    │
                    └─ NO ───► Either works; prefer dynamic
                               for simplicity at scale

Additional decisions:

Static variants + many replications?
  └─► HYBRID: tarchetypes::tar_map_rep()
      → topic-hybrid-branching.md

Encapsulating a reusable multi-target pattern?
  └─► TARGET FACTORY: tar_target_raw()
      → topic-target-factories.md

Approach Comparison

| Aspect | Static | Dynamic | Hybrid | |--------|--------|---------|--------| | When defined | Before tar_make() | During tar_make() | Both | | Target names | Friendly (analysis_bayesian) | Hashed (analysis_3a7f2b) | Mixed | | Scale | dplyr::filter(error != "")

Read specific branch by index

targets::tarread(targetname, branches = 1)

Inspect all branch metadata

targets::tarbranches(targetname)

### Debugging Strategies

1. **Start with `tar_manifest()`** - verify target count and commands before running
2. **Test with subset** - use `pattern = head(x, n = 3)` for initial runs
3. **Include provenance** - add parameter values to branch outputs for traceability
4. **Check upstream first** - use `tar_read()` on dependencies before investigating branching

## Common Mistakes

| Mistake | Problem | Fix |
|---------|---------|-----|
| `pattern = map(df$col)` | Can't reference external objects | Create upstream target |
| `method = c("fn_a", "fn_b")` | Strings aren't callable | `rlang::syms(c("fn_a", "fn_b"))` |
| Manual `lapply` + aggregation | Reinventing batching | Use `tar_rep()` or `tar_map_rep()` |
| `tar_make()` without validation | Errors discovered late | Always `tar_manifest()` first |
| `expand_grid()` with `syms()` inside | `syms()` doesn't expand in grid | Apply `syms()` after grid creation |

## See Also

- **r-metaprogramming**: Expression manipulation for target factories
- **tidy-evaluation**: Programming with data-masked functions
- [targetopia-packages.md](targetopia-packages.md): Package development workflows

## Reference Files

- [topic-static-branching.md](topic-static-branching.md) - Full static branching guide
- [topic-dynamic-branching.md](topic-dynamic-branching.md) - Full dynamic branching guide
- [topic-hybrid-branching.md](topic-hybrid-branching.md) - Dynamic within static patterns
- [topic-target-factories.md](topic-target-factories.md) - Custom factory functions
- [references/tarchetypes-functions.md](references/tarchetypes-functions.md) - Function reference
- [references/pattern-composition.md](references/pattern-composition.md) - Pattern algebra
- [references/targets-utilities.md](references/targets-utilities.md) - Package author utilities
- [templates/static-branching.R](templates/static-branching.R) - Static branching code template
- [templates/target-factory.R](templates/target-factory.R) - Target factory code template
- [targetopia-packages.md](targetopia-packages.md) - Targetopia package development guide

## External Resources

- [targets documentation](https://docs.ropensci.org/targets)
- [tarchetypes package](https://docs.ropensci.org/tarchetypes)
- [targets manual: dynamic branching](https://books.ropensci.org/targets/dynamic.html)
- [targets manual: static branching](https://books.ropensci.org/targets/static.html)

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [jsperger](https://github.com/jsperger)
- **Source:** [jsperger/llm-r-skills](https://github.com/jsperger/llm-r-skills)
- **License:** MIT

Install and usage instructions live in the source repository linked above.