R: bestanden Namen der Argumente erhalten in `...`

Question

In einer einfachen Funktion ... mit einer Liste der Argumente zu liefern, ist es möglich, die Funktion der Namen finden der übergebenen Objekte aus der Aufruf Umgebung? Wenn das so ist, wie?

Dies ergibt sich im Zusammenhang mit der Frage printing matrices and vectors side by side, ist aber wahrscheinlich allgemeiner.

In diesem Zusammenhang können die Argumente ... auch Zeichenfolgen enthalten, für die keine Namen erforderlich sind. Hier ist mein MWE, wo ich es mit deparse(substitute()) versucht habe, aber ohne Erfolg.

test_names <- function(...) { 
    # get arguments 
    args <- list(...) 
    chars <- sapply(args, is.character) 
    names <- sapply(args, function(x) if(is.character(x)) " " else deparse(substitute(x))) 
    names 
} 

Test:

A = matrix(c(0.5, 1, 3, 0.75, 2.8, 4), nrow = 2) 
x = c(0.5, 3.7, 2.3) 
y = c(0.7, -1.2) 
b = A %*% x - y 

> test_names(A, " * ", x, " - ", y, " = ", b) 
[1] "X[[i]]" " "  "X[[i]]" " "  "X[[i]]" " "  "X[[i]]" 
> 

Meine gewünschte Ausgabe hierfür wäre der Charakter Vektor der Länge sein 7:

[1] "A" " " "x" " " "y" " " "b" 

Es ist überraschend ist hier, dass die Ergebnisse sind alle X[[i]], wenn es ist nirgends X erwähnt.

@ Antwort des Roland Folgen, scheint dies zu tun, was ich will:

test_names2 <- function(...) { 
    argnames <- sys.call() 
    unlist(lapply(argnames[-1], as.character)) 
} 

> test_names2(A, " * ", x, " - ", y, " = ", b) 
[1] "A" " * " "x" " - " "y" " = " "b" 

Answer 1

Verwendung sys.call:

test_names <- function(...) { 
    argnames <- sys.call() 
    paste(lapply(argnames[-1], as.character), collapse = "") 
} 
#[1] "A * x - y = b" 

Answer 2

Da die E-Mail-Liste beschreibt (here) entweder sys.call wie Roland gesagt oder match.call kann dafür verwendet werden.

Im Vergleich zu Roland-Lösung sieht eine Lösung mit match.call wie

f = function(...){ 
    return(match.call()) 
} 

d = f(x = 1, b = 5) 
d 
#f(x = 1, b = 5) 
as.list(d[-1]) 
#$x 
#[1] 1 
# 
#$b 
#[1] 5 

So es so etwas verwenden, da das erste Element der Name der Funktion selbst ist.

f = function(...){ 
    return(as.list(match.call())[-1]) 
} 

---

Sie sind ähnlich, aber die help page sagt:

sys.call() ist ähnlich [match.call()], aber sich nicht ausdehnt, das Argument Namen;

Also hier ist ein Unterschied.