Est-il possible d'utiliser deux '...' états dans une fonction dans R?

Ces choses deviennent délicates, et il n'y a pas de solutions faciles sans spécifier d'arguments supplémentaires dans votre fonction. Si vous aviez ... dans les appels plot et legend, vous finiriez par recevoir des avertissements lors de la transmission d'arguments spécifiques à legend. Par exemple, avec:

foo.plot <- function(x,y,...) {
    plot(x,y,...)
    legend("bottomleft", "bar", pch = 1, ...)
}

Vous obtenez les avertissements suivants:

> foo.plot(1, 1, xjust = 0.5)
Warning messages:
1: In plot.window(...) : "xjust" is not a graphical parameter
2: In plot.xy(xy, type, ...) : "xjust" is not a graphical parameter
3: In axis(side = side, at = at, labels = labels, ...) :
  "xjust" is not a graphical parameter
4: In axis(side = side, at = at, labels = labels, ...) :
  "xjust" is not a graphical parameter
5: In box(...) : "xjust" is not a graphical parameter
6: In title(...) : "xjust" is not a graphical parameter

Il existe des façons de contourner ce problème, Voir plot.default et ses fonctions locales définies comme des wrappers autour de fonctions comme axis, box etc. où vous auriez quelque chose comme un localPlot() wrapper, fonction en ligne et appelez cela plutôt que plot() directement.

bar.plot <- function(x, y, pch = 1, ...) {
    localPlot <- function(..., legend, fill, border, angle, density,
                          xjust, yjust, x.intersp, y.intersp,
                          text.width, text.col, merge, trace, plot = TRUE, ncol,
                          horiz, title, inset, title.col, box.lwd,
                          box.lty, box.col, pt.bg, pt.cex, pt.lwd) plot(...)
    localPlot(x, y, pch = pch, ...)
    legend(x = "bottomleft", legend = "bar", pch = pch, ...)
}

(tout à fait pourquoi l'argument 'plot' a besoin d'une valeur par défaut est au-delà de moi, mais cela ne fonctionnera pas sans lui donner la valeur par défaut TRUE.)

Maintenant, cela fonctionne sans avertissements:

bar.plot(1, 1, xjust = 0.5, title = "foobar", pch = 3)

La façon dont vous gérez les paramètres graphiques comme bty par exemple dépendra de vous - bty affectera le type de zone de tracé et le type de zone de légende. Notez également que j'ai traité 'pch' différemment parce que si quelqu'un l'utilise argument dans l'appel bar.plot(), vous seriez i) en utilisant différents caractères dans la légende / intrigue et vous obtiendriez un avertissement ou une erreur sur 'pch' correspondant deux fois.

Comme vous pouvez le voir, cela commence à devenir assez délicat...

La réponse de Joris fournit une solution intéressante, que j'ai commentée m'a rappelé des arguments de listes de contrôle dans des fonctions comme lme(). Voici ma version de la réponse de Joris implémentant l'idée de cette idée de liste de contrôle:

la.args <- function(x = "bottomleft", legend = "bar", pch = 1, ...)
    c(list(x = x, legend = legend, pch = pch), list(...))

foo.plot <- function(x,y, legend.args = la.args(), ...) {
    plot(x, y, ...)
    do.call(legend, legend.args)
}

Qui fonctionne comme ceci, en utilisant le deuxième exemple d'appel de Jori, convenablement Modifié:

foo.plot(1,1, xaxt = "n", legend.args=la.args(bg = "yellow", title = "legend"))

Vous pouvez être aussi complet que vous le souhaitez lors de la configuration de la fonction la.args() - ici, Je ne définis que les paramètres par défaut pour les arguments mis en place par Joris et concaténer les autres. Ce serait plus facile si la.args() contenait tous les arguments de légende avec des valeurs par défaut.

Une solution consiste à utiliser des listes d'arguments en combinaison avec do.call. Ce n'est pas la plus belle solution, mais ça marche.

foo.plot <- function(x,y,legend.args,...) {
    la <- list(
        x="bottomleft",
        legend="bar",
        pch=1
    )
    if (!missing(legend.args)) la <- c(la,legend.args)
    plot(x,y,...)
    do.call(legend,la)
}
foo.plot(1,1, xaxt = "n")    
foo.plot(1,1, xaxt = "n",legend.args=list(bg="yellow",title="legend"))

Un inconvénient est que vous ne pouvez pas spécifier par exemple pch=2 par exemple dans la légende.liste args. Vous pouvez contourner cela avec quelques clauses if, je vous laisse le soin de jouer avec elle.

Edit : voir la réponse de M. Simpson pour une meilleure version de cette idée.

Nous pourrions construire une fonction formalize qui rendra n'importe quelle fonction compatible avec les points:

formalize <- function(f){
  # add ... to formals
  formals(f) <- c(formals(f), alist(...=))
  # release the ... in the local environment
  body(f)    <- substitute({x;y},list(x = quote(list2env(list(...))),y = body(f)))
  f
}

foo.plot <- function(x,y,...) {
  legend <- formalize(legend) # definition is changed locally
  plot(x,y,...)
  legend("bottomleft", "bar", pch = 1, ...)
}    

foo.plot(1,1, xaxt = "n", title = "legend")

Il montre cependant des avertissements, car plot reçoit des arguments qu'il n'attend pas.

Nous pourrions utiliser suppressWarnings sur l'appel de tracé (mais il supprimera tous les Avertissements évidemment), ou nous pourrions concevoir une autre fonction pour rendre la fonction plot (ou n'importe quelle fonction) localement plus tolérante aux points:

casualize <- function(f){
  f_name <- as.character(substitute(f))
  f_ns   <- getNamespaceName(environment(f))
  body(f) <- substitute({
      # extract all args
      args <- as.list(match.call()[-1]);
      # relevant args only
      args <- args[intersect(names(formals()),names(args))]
      # call initial fun with relevant args
      do.call(getExportedValue(f_ns, f_name),args)})
  f
}

foo.plot <- function(x,y,...) {
  legend <- formalize(legend)
  plot   <- casualize(plot)
  plot(x,y,...)
  legend("bottomleft", "bar", pch = 1, ...)
}

foo.plot(1,1, xaxt = "n", title = "legend")

Maintenant, cela fonctionne très bien!