How does R handle object in function call?

Question

I have background of Java and Python and I'm learning R recently.

Today I found that R seems to handle objects quite differently from Java and Python.

For example, the following code:

x <- c(1:10)
print(x)
sapply(1:10,function(i){
            x[i] = 4
        })
print(x)

The code gives the following result:

[1]  1  2  3  4  5  6  7  8  9 10
[1]  1  2  3  4  5  6  7  8  9 10

But I expect the second line of output to be all '4' since I modified the vector in the sapply function.

So does this mean that R make copies of objects in function call instead of reference to the objects?

Answer 1

x is defined in the global environment, not in your function.

If you try to modify a non-local object such as x in a function then R makes a copy of the object and modifies the copy so each time you run your anonymous function a copy of x is made and its ith component is set to 4. When the function exits the copy that was made disappears forever. The original x is not modified.

If we were to write x[i] <<- i or if we were to write x[i] <- 4; assign("x", x, .GlobalEnv) then R would write it back. Another way to write it back would be to set e, say, to the environment that x is stored in and do this:

e <- environment()
sapply(1:10, function(i) e$x[i] <- 4)

or possibly this:

sapply(1:10, function(i, e) e$x[i] <- 4, e = environment())

Normally one does not write such code in R. Rather one produces the result as the output of the function like this:

x <- sapply(1:10, function(i) 4)

(Actually in this case one could write x[] <- 4.)

ADDED:

Using the proto package one could do this where method f sets the ith component of the x property to 4.

library(proto)

p <- proto(x = 1:10, f = function(., i) .$x[i] <- 4)

for(i in seq_along(p$x)) p$f(i)
p$x

ADDED:

Added above another option in which we explicitly pass the environment that x is stored in.

Answer 2

Yes, you're right. Check the R Language Definition: 4.3.3 Argument Evaluation

AFAIK, R doesn't really copy the data until you're trying to modify it, thus following the Copy-on-write semantics.