`rowwise()` and empty input

[krlmlr]

Should we guarantee that the functions used in a rowwise mutate() or summarize() or reframe() always see length-one input? This is currently the case for everything but empty input, which creates a corner case to be worked around in user code. The example below shows mutate(), but the behavior is very similar for summarize() and reframe()

options(conflicts.policy = list(warn = FALSE))

library(dplyr)

tibble(a = 1L) |>
  rowwise() |>
  mutate(print(a))
#> [1] 1
#> # A tibble: 1 × 2
#> # Rowwise: 
#>       a `print(a)`
#>   <int>      <int>
#> 1     1          1

tibble(a = 1:3) |>
  rowwise() |>
  mutate(print(a))
#> [1] 1
#> [1] 2
#> [1] 3
#> # A tibble: 3 × 2
#> # Rowwise: 
#>       a `print(a)`
#>   <int>      <int>
#> 1     1          1
#> 2     2          2
#> 3     3          3

# Should this print `NA_integer_` ?
tibble(a = integer()) |>
  rowwise() |>
  mutate(print(a))
#> integer(0)
#> # A tibble: 0 × 2
#> # Rowwise: 
#> # ℹ 2 variables: a <int>, print(a) <int>

^{Created on 2024-06-12 with reprex v2.1.0}

[Raoul-Kima]

Intuitively I'd expect the following behaviour:
Rowwise groups by row. Then mutate executes print once for each group. Since there are 0 rows there are 0 groups, so print gets executed 0 times.
But this is not a clean solution either:
Imagine this situation: instead of mutate(print(a)) there is mutate(b=someFunction(a)), that is: the return of someFunction gets stored in column b.
In this case if someFunction wouldn't get called at all then it would be unknown what the type of column b should be.
but if it gets called with a length 1 input, it would probably return a length 1 output. Where should this value be stored, given that the data.frame contains zero groups?
From that perspective calling someFunction on a zero length input seems best: it would probably return a zero length output, allowing the creation of column "b" with the correct type, without giving a value that needs to be stored somewhere.

A similar case also arises when using group_by() on an empty data.frame.

[Raoul-Kima]

Thinking more about this:

A disadvantage of calling someFunction() with a length zero argument is that it requires that function to be able to handle that, which is a bit unintuitive after rowwise(), which i guess is one of the initial motivations for this issue. If someFunction() is a vectorized function one could assume that it can handle vectors of length 0. In a way that means that one needs to use vectorized functions after rowwise(), even though rowwise() implies that this isn't necesary (and might be used exactly because of that).

If someFunction() would be called with a length one argument, one could just discard the return value and only use its type to create the return column (e.g. by doing column=x[integer()] if the return is x).
But: It is unclear what value to use to call someFunction, since the data frame doesn't contain any. The function might throw or do other undesireable things for some values, so just picking a random value doesn't work reliably either.
If someFunction() has side effects then calling it on anything other then length zero input can have unintended side effects. This can also happen with a length zero input (if the user assumes that the function isn't called at all for zero length data.frames), but seems less likely.

I'd suggest that the documentation of rowwise() should mention how it handles such cases, since there doesn't seem to be a 100% intuitive solution. (and in the same vein, the group_by() documentation should mention how it handles cases with zero groups)