targets patterns (map(), cross(),
slice(), …). Used unquoted in pattern on
tar_target_rs() / tar_target_rs_raw(), they
compile the Rust crate a single time in a companion
<step name>_rust_lib target and reuse that compiled
library across every branch (each branch reloads it in milliseconds),
instead of recompiling the crate in every branch as the plain
targets patterns do. On the other constructors
(tar_target_py(), tar_target_jl(), or
tar_target()) each helper falls back to its plain
targets equivalent, so the same pattern code branches every
language.
tarpolyglot_map(): equivalent to
map()tarpolyglot_cross(): equivalent to
cross()tarpolyglot_slice(): equivalent to
slice()tarpolyglot_head(): equivalent to
head()tarpolyglot_tail(): equivalent to
tail()tarpolyglot_sample(): equivalent to
sample()tar_code() now runs
correctly when it spans multiple top-level statements (for example a
function definition followed by a call). It is evaluated as
a Julia script rather than as a single expression, so it no longer
raises ParseError("extra token after end of expression").
Inline Python and Rust were unaffected.First release. tarpolyglot adds targets
constructors that run Python, Julia, and Rust as pipeline steps.
tar_target_py(), tar_target_jl(), and
tar_target_rs() (with matching _raw()
variants) mirror targets::tar_target() /
targets::tar_target_raw(). Python and Julia steps run a
script through a live interpreter (reticulate / JuliaCall) with optional
R pre- and post-scripts; Rust steps compile #[extendr]
functions with rextendr and call them from an R post-script.output = "file").tar_target_path() tracks a script file as a real
targets dependency, so a step re-runs when its script
changes.polyglot_controller() provides a crew
controller preconfigured for per-step interpreter isolation
(tasks_max = 1).env /
env_manager (system, virtualenv, venv, uv, poetry, conda),
python_version, or an explicit python path;
Julia selection via julia_version / julia_home
/ julia_project / julia_packages.targets::tar_target_raw() argument pass-through,
including dynamic branching (pattern).tar_code() supplies inline code for the
script, pre_script, and
post_script arguments of the constructors, as an
alternative to a file path or a tar_target_path()
reference. An R {...} block is captured as inline R and is
valid in the pre_script / post_script slots; a
character string is inline source for the foreign script
(Python, Julia, or Rust) or for an R pre/post-script. Multi-line strings
are dedented, so code indented to line up with _targets.R
still starts flush-left and Python’s own block indentation stays valid.
Inline code is embedded in the target’s command, so targets
hashes it and re-runs the step when it changes.