如何从调用环境而不是封闭环境中获取 R 函数的默认值

Question

R assign() within function fails when nesting source()-ed file, but assign() on its own works.

My group has many R programs that call other programs. We've created a getObjectFromCalledProgram() function to use with source(..., local = calledProgram <- new.env()) to select specific objects from called programs. I've just found that this does not work when sourced programs are nested within each other. I'd like to understand whether I can alter our getObjectFromCalledProgram() function rather than finding and editing all of the programs in which we've used this approach.

Can someone explain why our getObjectFromCalledProgram() function, which very simply uses the assign() function, fails within a source()-ed program, where the assign function, used directly, works?

Here is an example. See where exists("subSourceMeObject") returns FALSE after the getObjectFromCalledProgram() function, but TRUE after the assign() function:

## Program1 ##
getObjectFromCalledProgram <-function(objectName) assign(x=objectName, value=calledProgram[[objectName]], env = parent.frame())

# set up the program files to be source()-ed
Program3 <- tempfile()  # this program will be called (source()-ed) within a source()-ed program.
writeLines(c('  ## Program3 ## ','  Program3Object <- "object3" '), con=Program3)

Program2 <- tempfile()     # this will be the secondary program, called (source()-ed) by this main program.
writeLines(c(' ## Program2 ##                                                '
             , ' Program2Object <- "object2"                                   '
             , ' source(Program3, local=calledProgram <- new.env(), echo = T)  '
             , ' # Use getObjectFromCalledProgram() to put subSourceMeObject into Program2\'s environment.'           
             , ' (getObjectFromCalledProgram("Program3Object"))                '
             , ' # That DOES NOT WORK. It returns NULL. I.e., the assign() within getObjectFromCalledProgram() fails.'
             , ' exists("Program3Object")  # returns FALSE                     '
             , ' # Use assign() directly rather than within the Program3Object function. WORKS.'
             , ' (assign("Program3Object", calledProgram[["Program3Object"]])) '
             , ' exists("Program3Object")  # returns TRUE                      '
             , ' # That WORKS. It returns "object2". I.e., the assigs() function did pull Program3Object into Program2\'s environment. '
)
, con=Program2
)

# source() those program files.
source(Program2, local=calledProgram <- new.env(), echo = T)
# Pull the created Program2Object and Program3Object into Program1's unlist(lapply(c("Program2Object", "Program3Object"), exists))  # the objects don't exist in Program1's environment.
environment, to show that getObjectFromCalledProgram() works.
(getObjectFromCalledProgram("Program2Object"))  # put Program2Object into Program1's environment.
(getObjectFromCalledProgram("Program3Object"))  # put Program3Object into Program1's environment.
unlist(lapply(c("Program2Object", "Program3Object"), exists))  # the objects now exist in Program1's environment.
rm(getObjectFromCalledProgram, Program2, Program3, Program2Object, Program3Object)  # Clean up.

Answer 1

I figured it out, thanks to https://stackoverflow.com/a/49385368/3799203 . Rather than myArg = rObject , I needed to use myArg = parent.frame()$rObject , to tell R to look in the calling environment for rObject, rather than looking in the enclosing environment (ie, rather than looking in the environment where the function was created).

Details: From http://adv-r.had.co.nz/Environments.html#function-envs I learned that in R, function default values are taken from the function's enclosing environment, not the calling environment (the environment in which the function was called). I'm guessing that "look in the containing environment" approach is handy when creating packages, since it lets functions find other things in the same package.

# Simple example: x in myArg=x uses the x object in the enclosing environment, i.e., the environment where myF was created.
myF <- function(myArg=x) {print(paste("myF returns:",myArg))}
x <- "x from enclosing environment"
myF()
#> [1] "myF returns: x from enclosing environment"
with(env2<-new.env(), {
  x <- "x from calling environment"
  myF()  # returns the value of x from in the environment where the function was created.
  myF(myArg=x)  # If I explicitly pass a value to the myArg argument, R starts its search for x from the current environment.
})
#> [1] "myF returns: x from enclosing environment"
#> [1] "myF returns: x from calling environment"
rm(x, myF, env2)

# Use parent.frame()$... to have the default argument values set by the calling environment rather than by the containing environment:
myF <- function(myArg=parent.frame()$x) {print(paste("myF returns:",myArg))}
x <- "x from enclosing environment"
myF()
#> [1] "myF returns: x from enclosing environment"
with(env2<-new.env(), {
  x <- "x from calling environment"
  myF()  # the function used "parent.frame()$x" as the default value, R starts its search for x from the calling environment (the environment where the function was executed).
  myF(myArg=x)
})
#> [1] "myF returns: x from calling environment"
#> [1] "myF returns: x from calling environment"
rm(x, myF, env2)

^{Created on 2021-10-15 by the reprex package (v2.0.1)}