To extract the number and names of the arguments from a function or function[something] to return ("arg1", "arg2"), we use the inspect module. The given code is written as follows using inspect module to find the parameters inside the functions aMethod and foo.
Get the List of Arguments of a Function in R Programming – args() Function. args() function in R Language is used to get the required arguments by a function. It takes function name as arguments and returns the arguments that are required by that function.
The parameter list of a function describes the number and types of the arguments that the function accepts, and the number and types of the values it returns. The parameter list of a generic function is used to define the overall protocol of the generic function.
One solution is to use:
tempf <- function(a, b = 2, ...) {
argg <- c(as.list(environment()), list(...))
print(argg)
}
tempf(1, c = 3)
$a
[1] 1
$b
[1] 2
$c
[1] 3
This creates a named list of the argument values.
I think that you want match.call
:
tmpfun <- function(a,b,...) {
print(as.list(match.call()))
print(as.list(match.call(expand.dots=FALSE)))
}
> tmpfun(a=1, b=2, c=3, d=4)
[[1]]
tmpfun
$a
[1] 1
$b
[1] 2
$c
[1] 3
$d
[1] 4
[[1]]
tmpfun
$a
[1] 1
$b
[1] 2
$...
$...$c
[1] 3
$...$d
[1] 4
try args
function
What are the arguments for mean
function?
> args(mean)
function (x, ...)
NULL
What about lm
function?
> args(lm)
function (formula, data, subset, weights, na.action, method = "qr",
model = TRUE, x = FALSE, y = FALSE, qr = TRUE, singular.ok = TRUE,
contrasts = NULL, offset, ...)
NULL
If you want to get a list of arguments try
as.list(args(lm))
Stumbled upon this question while searching for something related. While I realize that this is several years old, the responses appear unsatisfactory, and there does not appear to be any off-the-shelf solution to the question.
It is possible to make an (inelegant) workaround, using a combination of the formals
and environment
functions. The example below extracts arguments from the environment using names extracted from formals, then appends the ellipsis-list. If you wish to have the values as they were set at the time of function call, set the orig_values argument to TRUE. The function only includes variables implicitly or explicitly set at function call.
allargs <- function(orig_values = FALSE) {
# get formals for parent function
parent_formals <- formals(sys.function(sys.parent(n = 1)))
# Get names of implied arguments
fnames <- names(parent_formals)
# Remove '...' from list of parameter names if it exists
fnames <- fnames[-which(fnames == '...')]
# Get currently set values for named variables in the parent frame
args <- evalq(as.list(environment()), envir = parent.frame())
# Get the list of variables defined in '...'
args <- c(args[fnames], evalq(list(...), envir = parent.frame()))
if(orig_values) {
# get default values
defargs <- as.list(parent_formals)
defargs <- defargs[unlist(lapply(defargs, FUN = function(x) class(x) != "name"))]
args[names(defargs)] <- defargs
setargs <- evalq(as.list(match.call())[-1], envir = parent.frame())
args[names(setargs)] <- setargs
}
return(args)
}
tempf <- function(a, b = 2, ...) {
d <- 5
b <- 3
cat("Currently set values defined in call or formals\n")
print(allargs())
cat("Values as defined at the time of the call\n")
print(allargs(T))
}
tempf(1, c = 3)
Currently set values defined in call or formals
$a
[1] 1
$b
[1] 3
$c
[1] 3
Values as defined at the time of the call
$a
[1] 1
$b
[1] 2
$c
[1] 3
I believe you are looking for formals
:
formals(sd)
$x
$na.rm
[1] FALSE
And using dput
on this gives you the form you specify in the question:
dput(formals(sd))
list(x = , na.rm = FALSE)
Note that formals
doesn't work for primitive functions, only closures.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With