Rename column when a symbol is named in xnew_data()

[joethorley]

Closes #99. Closes #109.

xnew_data(Year, Length = lengths) produced a data frame column Length$lengths instead of a new column Length, and other named arguments either ignored .length_out or were packed the same way.

A bare symbol is translated into xnew_seq(), which returns a one column tibble named after the symbol.
When the argument was also named, tidyr::expand() stored that tibble as a data frame column.
A named bare vector reached expand() directly, which expands a factor to all of its levels and so discarded .length_out and .obs_only.

Every named argument is now passed through xnew_column(), which applies the argument name to the value itself and drops the outer name:

• a bare vector is wrapped in a one column tibble of that name;
• a one column data frame has its column renamed;
• a multi column data frame, such as tidyr::nesting(), is packed into a data frame column as before;
• NULL is dropped, as expand() did before.

xnew_data(data.frame(lengths = 1:2), Length = lengths)
#> # A tibble: 2 x 2
#>   lengths Length
#>     <int>  <int>
#> 1       1      1
#> 2       1      2

d <- tibble::tibble(a = 1:5 + 0.5, b = factor(letters[1:5]))
xnew_data(d, z = new_seq(b, .length_out = 2))$z
#> [1] a b
#> Levels: a b c d e

The user's quosure is nested inside one evaluated in the package namespace so the internal helper is in scope without inlining the function object.
The semantics of named arguments are documented in the details section.

Adds regression tests and examples. R CMD check: 0 errors, 0 warnings, 0 notes.

Name handling inside xobs_only() is tracked separately in #111.

🤖 Generated with Claude Code

[Copilot]

Pull request overview

Fixes xnew_data() behavior when a bare-symbol argument is also named (e.g., Length = lengths), which previously caused tidyr::expand() to create a nested data-frame column (printed as Length$lengths) instead of a proper new column.

Changes:

• Propagate argument names into translation so that named bare symbols are converted to a one-column tibble renamed to the supplied name, while dropping the outer argument name to avoid nested columns in tidyr::expand().
• Add regression tests covering column naming and .length_out behavior for named symbols (including factors).
• Add an example documenting that naming a variable creates a new column of that name.

Reviewed changes

Copilot reviewed 2 out of 3 changed files in this pull request and generated no comments.

File	Description
R/xnew-data.R	Renames one-column tibbles produced from bare symbols when the argument is named, and drops the outer name to avoid nested columns in tidyr::expand().
tests/testthat/test-xnew-data.R	Adds regression tests for named-symbol column creation and .length_out behavior (including factor level preservation).
man/xnew_data.Rd	Updates generated documentation examples to illustrate the named-symbol behavior.

Files not reviewed (1)

• man/xnew_data.Rd: Generated file

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.

[StefanoMezzini]

added some tests for using a preexisting vector object instead of a data.frame column

[StefanoMezzini]

accidentally approved instead of requesting changes. see requested changes above

[claude]

Claude Code Review

Claude Code Review is paused for this repository. To reconnect it, an admin of this repository's GitHub organization (or the account owner, for personal repositories) who can also manage your Claude organization's Code Review settings needs to re-link GitHub in Code Review settings. This is a one-time step.

_{Tip: disable this comment in your organization's Code Review settings.}

[StefanoMezzini]

The code seems to be working well, but I can't comment on whether the changes are ideal. I understand what the diffused expressions are doing, but I am not familiar enough with the functions to provide any additional useful feedback, so I'll leave that to @krlmlr.

[krlmlr]

Why not just

expr_translate_xnew_data <- function(expr, name, length_out) {
  if (!is_symbol(expr)) {
    return(expr)
  }

  if (name == "") {
    # Unnamed: return tibble
    expr(xnew_seq(!!expr, .length_out = !!length_out))
  } else {
    # Named: return first column of tibble as a vector,
    # new name will be applied externally
    expr(xnew_seq(!!expr, .length_out = !!length_out)[[1]])
  }
}

and with just the imap() change? What am I missing?

[krlmlr]

On the other hand, enquos() might always set names:

names_enquos <- function(...) {
  names(rlang::enquos(...))
}

names_enquos(a = 3)
#> [1] "a"
names_enquos(a, 3)
#> [1] "" ""

^{Created on 2026-09-02 with reprex v2.1.1}

[joethorley]

Why not just ... and with just the imap() change? What am I missing?

The one column tibble is load-bearing. expand() sorts and deduplicates either way, so that
is not the distinction, but a bare factor vector is expanded to all of its levels whereas
a factor held in a data frame keeps only the values present:

d <- tibble::tibble(a = 1:5 + 0.5, b = factor(letters[1:5]))

tidyr::expand(d, z = factor(c("b", "a"), levels = letters[1:5]))$z
#> [1] a b c d e
#> Levels: a b c d e
tidyr::expand(d, tibble::tibble(z = factor(c("b", "a"), levels = letters[1:5])))$z
#> [1] a b
#> Levels: a b c d e

That level expansion silently discards .length_out and .obs_only, so with [[1]] the
named symbol respects .length_out (#99) test fails:

`actual`:   "a" "b" "c" "d" "e"
`expected`: "a" "b"

On imap(): you are right that enquos() always sets names, so it is safe here.
names(enquos()) is character(0) and entries are "" otherwise, never NULL.
Worth noting that names(translated)[symbol] <- "" two lines down makes the same
assumption (with NULL names it yields NA names), so hardening one without the other
buys nothing.

Your question did turn up something real though.
The named non-symbol paths never got the tibble wrapper and are still broken:

xnew_data(d, z = new_seq(b, .length_out = 2))$z
#> [1] a b c d e

That is the idiom shown in xnew_seq()'s own examples, so it is reachable straight from the
documentation. Filed as #109 and fixed in #110, which also makes the names2() question moot
by dropping the outer name for every named argument rather than only for symbols.

[joethorley]

@krlmlr see response drafted by Fable above.

[krlmlr]

I was thinking that we could just always wrap in tibbles and pass them as unnamed objects to expand(), thus concentrating the naming logic into one place. This seemed overkill but the named non-symbol case seems convincing. I guess I'm confused by the split in the naming logic across two functions.

[joethorley]

This was the problem reprex

library(newdata)
Year <- data.frame(lengths = 1:2)
xnew_data(Year, Length = lengths)
#> # A tibble: 2 × 2
#>   lengths Length$lengths
#>     <int>          <int>
#> 1       1              1
#> 2       1              2

^{Created on 2026-09-08 with reprex v2.1.1}