Writings functions (procedures) for data.table objects

Question

In the book Software for Data Analysis: Programming with R, John Chambers emphasizes that functions should generally not be written for their side effect; rather, that a function should return a value without modifying any variables in its calling environment. Conversely, writing good script using data.table objects should specifically avoid the use of object assignment with `<-`, typically used to store the result of a function. First, is a technical question. Imagine an R function called `proc1` that accepts a `data.table` object `x` as its argument (in addition to, maybe, other parameters). `proc1` returns NULL but modifies `x` using `:=`. From what I understand, `proc1` calling `proc1(x=x1)` makes a copy of `x1` just because of the way that promises work. However, as demonstrated below, the original object `x1` is still modified by `proc1`. Why/how is this? ``` > require(data.table) > x1 <- CJ(1:2, 2:3) > x1 V1 V2 1: 1 2 2: 1 3 3: 2 2 4: 2 3 > proc1 <- function(x){ + x[,y:= V1*V2]…

Accepted Answer

Yes, the addition, modification, deletion of columns in `data.table`s is done by `reference`. In a sense, it is a good thing because a `data.table` usually holds a lot of data, and it would be very memory and time consuming to reassign it all every time a change to it is made. On the other hand, it is a bad thing because it goes against the `no-side-effect` functional programming approach that R tries to promote by using `pass-by-value` by default. With no-side-effect programming, there is little to worry about when you call a function: you can rest assured that your inputs or your environment won't be affected, and you can just focus on the function's output. It's simple, hence comfortable.

Of course it is ok to disregard John Chambers's advice if you know what you are doing. About writing "good" data.tables procedures, here are a couple rules I would consider if I were you, as a way to limit complexity and the number of side-effects:

- a function should not modify more than one table, i.e., modifying that table should be the only side-effect,

- if a function modifies a table, then make that table the output of the function. Of course, you won't want to re-assign it: just run `do.something.to(table)` and not `table <- do.something.to(table)`. If instead the function had another ("real") output, then when calling `result <- do.something.to(table)`, it is easy to imagine how you may focus your attention on the output and forget that calling the function had a side effect on your table.

While "one output / no-side-effect" functions are the norm in R, the above rules allow for "one output or side-effect". If you agree that a side-effect is somehow a form of output, then you'll agree I am not bending the rules too much by loosely sticking to R's one-output functional programming style. Allowing functions to have multiple side-effects would be a little more of a stretch; not that you can't do it, but I would try to avoid it if possible.

Writings functions (procedures) for data.table objects

Solution

Problem

Related problems