Let's break down what the apply parameter does, diagnose why your apply=TRUE code is failing, and fix it step by step.

What apply=TRUE/FALSE Actually Controls #

The apply parameter changes how your target function interacts with grouped or full datasets:

• apply=FALSE (default): Your function runs in a vectorized way. If you specify a grouping variable with by, it operates directly on each group's value vector—this is ideal for functions designed to handle vectors (like most of collapse's built-ins, including flag()). It’s fast and leverages vectorization for performance.
• apply=TRUE: Your function treats each group as a single "chunk" of data (similar to lapply over groups). Use this only for custom functions that need to work with the entire group’s data at once (e.g., complex rolling calculations that depend on the full group context). The function must return a result with the same number of rows as the group to be combined correctly.

Why Your apply=TRUE Code Fails #

Looking at your code, two critical issues are causing the error:

1. Misplaced parameters: You’re passing group and counter as extra arguments to flag() instead of using them as grouping/sorting parameters for settransformv(). The flag() function doesn’t accept these inputs—this leads to invalid arguments when apply=TRUE tries to run the function per group.
2. Incorrect grouping logic: If you intended to calculate lags within each group, you didn’t explicitly set the by parameter. Instead, your code is forcing flag() to process invalid inputs, which breaks when apply=TRUE tries to handle tiny, unintended groups.

When apply=TRUE is active, the function attempts to run flag(xval, 1:3, group, counter) on each misconfigured "group" (effectively each row), and flag() can’t handle those extra arguments or the tiny group size.

Fixed Code Examples #

Let’s adjust your code to correctly calculate lags of xval within each group, ordered by counter, and show how apply works in both modes.

Using apply=FALSE (Vectorized, Recommended) #

This is the fastest approach for vectorized functions like flag():

library(collapse)
library(data.table)

lagamount <- 1
testdf_1 <- data.table(group = c(1,1,1,1,1,2,2,2,2,2), 
                       counter = as.integer(c(1,2,3,5,6,7,8,9,11,12)), 
                       xval = seq(100, 1000, 100))
testdf_2 <- copy(testdf_1)

# Correct: Group by 'group', sort by 'counter' for proper lag order
settransformv(testdf_1, "xval", flag, 1:3, by = group, sort = counter, apply = FALSE)
testdf_1

Here:

• by = group ensures lags are calculated within each group.
• sort = counter orders each group by the sequence column first (critical since your counter has gaps).
• apply=FALSE lets flag() run vectorized over each group’s xval, returning 3 lag columns automatically named xval.1, xval.2, xval.3.

Using apply=TRUE (For Group-Wise Custom Functions) #

Use this only if you need a function that operates on the entire group at once:

# Custom function to calculate lags for a full group, ordered by counter
group_lag <- function(group_data, n) {
  # Sort the group by counter first
  ordered_data <- group_data[order(counter)]
  # Calculate lags on the sorted xval
  flag(ordered_data$xval, n = n)
}

# Apply the custom function per group
settransformv(testdf_2, "xval", group_lag, 1:3, by = group, apply = TRUE)
testdf_2

Here:

• apply=TRUE runs group_lag() on each full group (a subset of the data.table with all rows from one group).
• Our custom function first sorts the group by counter, then calculates lags on the ordered values.

Key Takeaways #

• Stick with apply=FALSE for built-in vectorized functions—it’s simpler and faster.
• Use apply=TRUE only for custom functions that require full group context.
• Always explicitly define by and sort parameters instead of passing grouping variables to your target function—this avoids parameter confusion.

内容的提问来源于stack exchange，提问作者Vitalijs