do.call Umgebung angeben innen Funktion

Question

Ich verwende die folgenden in einem Paket konstruieren,

## two functions in the global environment 
funa <- function(x) x^2 
funb <- function(x) x^3 
## called within a function, fine 
fun_wrap <- function(){ 
    lapply(c('funa', 'funb'), do.call, list(x=3)) 
} 

fun_wrap() 
[[1]] 
[1] 9 

[[2]] 
[1] 27 

aber ich habe durch die Tatsache gerade gebissen, dass es nicht funktioniert, wenn die Funktionen sind in einem andere (lokale) Rahmen,

## same construct, but the functions are local 
fun_wrap1 <- function(){ 
    funa1 <- function(x) x^2 
    funb1 <- function(x) x^3 
    lapply(c('funa1', 'funb1'), do.call, list(x=3)) 
} 
## now it fails 
fun_wrap1() 
##Error in FUN(c("funa1", "funb1")[[1L]], ...) : 
## could not find function "funa1" 

ich habe versucht, envir=parent.frame(2)-do.call() vorbei (nicht funktioniert); Offen gesagt geht die Hilfeseite von ?parent.frame weit über meinen Kopf. Irgendein Hinweis für eine robustere Verwendung von do.call?

Beachten Sie, dass die Liste der Funktionen als ein Zeichenvektor kommt, der von einem anderen Codeabschnitt übergeben wird; Ich bevorzuge es, die Funktionen nicht direkt zu übergeben.

Edit: eine weitere Wendung ... Ich dachte, dass ich das richtige Problem mit meinem Spielzeug Beispiel illustriert hatte, aber der eigentliche Code ich benutze ist etwas anders, in dem Sinne, dass ich telefonieren bin fun_wrap1 innerhalb eine separate Funktion. Die vorgeschlagenen Lösungen scheitern in diesem Zusammenhang.

fun_wrap1 <- function(funs){ 
    lapply(funs, do.call, args=list(x=3), envir=environment()) 
} 

foo <- function(){ 
    funa1 <- function(x) x^2 
    funb1 <- function(x) x^3 
fun_wrap1(c('funa1', 'funb1')) 
} 

foo() 
##Error in FUN(c("funa1", "funb1")[[1L]], ...) : 
## could not find function "funa1" 

(und das gleiche passiert mit dem match.fun Ansatz)

Ich kann es erhalten, indem eine optionale Umgebung fun_wrap1 zu arbeiten,

fun_wrap1 <- function(funs, e=parent.frame()){ 
    lapply(funs, do.call, args=list(x=3), envir=e) 
} 

foo <- function(){ 
    funa1 <- function(x) x^2 
    funb1 <- function(x) x^3 
    fun_wrap1(c('funa1', 'funb1')) 
} 

foo() 

und das ist hoffentlich.

Answer 1

Dies scheint zu funktionieren, aber ich bin nicht sicher, ob es andere Auswirkungen hat Ich erwäge nicht:

fun_wrap1 <- function(){ 
    funa1 <- function(x) x^2 
    funb1 <- function(x) x^3 
    lapply(c('funa1', 'funb1'), do.call, args=list(x=3), envir=environment()) 
} 

fun_wrap1() 
#[[1]] 
#[1] 9 
# 
#[[2]] 
#[1] 27 

Also das im Wesentlichen äquivalent ist, die lapply Anweisung, wie:

lapply(
     c('funa1', 'funb1'), 
     function(f) do.call(f, args=list(x=3), envir=environment()) 
    ) 

Answer 2

Offensichtlich funktioniert es, wenn wir die Funktionen in fun_wrap2 auswerten. Das Problem mit dem Ansatz in der Frage besteht darin, dass die Zeichenfolgen in Funktionen innerhalb einer der Verarbeitungsfunktionen konvertiert werden, die den Suchpfad ändern.

fun_wrap2 <- function(){ 

    funa1 <- function(x) x^2 
    funb1 <- function(x) x^3 

    nms <- c("funa1", "funb1") 
    funs <- lapply(nms, match.fun) 
    lapply(funs, do.call, list(x=3)) 

} 

fun_wrap2() 

Answer 3

Eine etwas einfachere Version von @ g-Grothen Antwort. Anstatt die Funktionsnamen zu verwenden, fügen wir die Funktionen selbst in die Liste ein, die an lapply übergeben wird.

fun_wrap1 <- function(){ 
    funa1 <- function(x) x^2 
    funb1 <- function(x) x^3 
    lapply(list(funa1, funb1), do.call, list(x=3)) 
} 

fun_wrap1()