Warum "fehlt" und default-Argumente werden in der Funktion `lapply`?

Werde ich zunächst erwähnen, dass ich glaube, dass die idiomatischen Weg dies zu tun ist, indem er einen Anruf und dann zu bewerten. Sehen write.csv für ein Beispiel. Ich glaube, dieser code tut, was Sie möchten, mit dieser Methode.

wrapper <- function(X, arg, ...) {
  force(X) # optional; if X is missing, the error message will be more informative
  Call <- match.call(expand.dots=TRUE)
  Call[[1L]] <- as.name("lapply")
  Call$FUN <- as.name(".add")
  eval.parent(Call)
}

Ok, hier ist nun ein Versuch, zu erklären, die Probleme, die Sie entdeckt. Ich stehe bereit, korrigiert zu werden, als gut, aber hoffentlich wird dies wenigstens helfen, klären die Fragen, wie @idfah Antwort haben.

Zunächst werde ich die Bewältigung der "defaults" - Problem, wie ich denke, es ist mehr einfach. Dieses ich denken kann gemacht werden einfacher, da in den beiden folgenden Funktionen, wobei die zweite (f2) ruft einfach die erste (f1). Was wir sehen, ist, dass das Standard-argument in f1 wird überschrieben durch das Versprechen x im f2, und wenn das Versprechen ausgewertet wird, vorhanden ist. Moral von dieser Geschichte (finde ich); Standard: muss festgelegt werden, wieder in das aufrufende Funktion, wenn die variable enthalten ist, in den Aufruf.

f1 <- function(x=1) {print(match.call()); x}
f2 <- function(x) {f1(x=x)}
f1()
## f1()
## [1] 1
f2()
## f1(x = x)
## Error in f1(x = x) : argument "x" is missing, with no default

Nun zu den fehlenden in lapply Problem. Hier bin ich im Grunde genommen haben sgibb code, aber haben Hinzugefügt, eine Nachricht darüber, ob es nicht arg ist, als vermisst. Haben wir, was scheint zu sein eine merkwürdige Widerspruch; die Nachricht sagt uns, dass arg fehlt NICHT, aber wenn die Funktion versucht, darauf zuzugreifen, bekommen wir eine Fehlermeldung, die uns sagt, dass arg fehlt.

.add <- function(x, arg) {
  print(match.call())
  if(missing(arg)) {
    message("arg is missing in .add")
    x
  } else {
    message("arg is not missing")
    x + arg
  }
}
wrapper <- function(l, arg) {lapply(l, .add, arg=arg)}
wrapper(1)
## FUN(x = 1[[1L]], arg = ..1)
## arg is not missing
## Error in FUN(1[[1L]], ...) : argument "arg" is missing, with no default

Was ich denke, passiert ist, das lapply ist, dass wir die Versprechen arg im ..1, also es sieht nicht so fehlen, aber wenn er versucht, es zu bewerten, es findet, dass es fehlt. Moral von dieser Geschichte (finde ich); Versuch nicht, Sie zu propagieren missings durch lapply.

UPDATE: genauer gesagt, es etwas wie ein dot expansion arbeitet. Betrachten Sie diese version von lapply (die ja eigentlich nicht arbeiten, auf einer Liste, aber ansonsten hat die gleiche code-Stil); dies zeigt, bekommen wir das gleiche Verhalten.

apply3 <- function(X, FUN, ...) { 
  print(match.call())
  FUN(X, ...)
}
wrapper3 <- function(l, arg) {apply3(l, .add, arg=arg)}
wrapper3(1)
## apply3(X = l, FUN = .add, arg = arg)
## FUN(x = X, arg = ..1)
## arg is not missing
## Error in FUN(X, ...) : argument "arg" is missing, with no default

Aber wenn wir ersetzen die Punkte durch eine variable Namen, funktioniert es wie erwartet.

apply4 <- function(X, FUN, hm) { 
  print(match.call())
  FUN(X, hm)
}
wrapper4 <- function(l, arg) {apply4(l, .add, hm=arg)}
wrapper4(1)
## apply4(X = l, FUN = .add, hm = arg)
## FUN(x = X, arg = hm)
## arg is missing in .add
## [1] 1

Und noch ein Beispiel; wenn ich mit dots, aber die expansion selbst, durch die Berufung ..1 direkt, es funktioniert auch! Dies ist neugierig, wie die aufeinander abgestimmten call ist die gleiche wie die version, die nicht funktioniert.

apply3b <- function(X, FUN, ...) { 
  print(match.call())
  FUN(X, ..1)
}
wrapper3b <- function(l, arg) {apply3b(l, .add, arg=arg)}
wrapper3b(1)
## apply3b(X = l, FUN = .add, arg = arg)
## FUN(x = X, arg = ..1)
## arg is missing in .add
## [1] 1