CODEWITHSUNDEEP
rfunctionparameters
Chris Cox
Chris Cox

Reputation: 400

R: Passing parameters from a wrapper function to internal functions

I am not surprised that this function doesn't work, but I cannot quite understand why.

computeMeans <- function(data,dv,fun) {
    x <- with(data,aggregate(dv,
        list(
            method=method,
            hypo=hypothesis,
            pre.group=pre.group,
            pre.smooth=pre.smooth
        ),
        fun ) )
    return(x)
}

computeMeans(df.basic,dprime,mean)

Where df.basic is a dataframe with factors method, hypothesis, etc, and several dependent variables (and I specify one with the dv parameter, dprime).

I have multiple dependent variables and several dataframes all of the same form, so I wanted to write this little function to keep things "simple". The error I get is:

Error in aggregate(dv, list(method = method, hypo = hypothesis, 
pre.group = pre.group,  : 
    object 'dprime' not found

But dprime does exist in df.basic, which is referenced with with(). Can anyone explain the problem? Thank you!

EDIT: This is the R programming language. http://www.r-project.org/

Upvotes: 3

Views: 1623

Answers (3)

Josh O&#39;Brien
Josh O&#39;Brien

Reputation: 162321

Passing in the dprime argument as a character string would allow you to sidestep any consideration of the involved scoping and evaluation rules discussed in @Michael's answer:

computeMeans <- function(data, dv, fun) {
    x <- aggregate(data[[dv]],
        list(
            method = data[["method"]],
            hypo = data[["hypothesis"]],
            pre.group = data[["pre.group"]],
            pre.smooth = data[["pre.smooth"]]
        ),
        fun )
    return(x)
}
computeMeans(df.basic, "dprime", mean)

Upvotes: 2

Michael
Michael

Reputation: 5898

Alternatively

computeMeans <- function(data,dv,fun) {
    dv <- eval(substitute(dv), envir=data)
    x <- with(data,aggregate(dv,
        list(
            method=method,
            hypo=hypothesis,
            pre.group=pre.group,
            pre.smooth=pre.smooth
        ),
        fun ) )
    return(x)
}

You might think that since dv is in the with(data, (.)) call, it gets evaluated within the environment of data. It does not.

When a function is called the arguments are matched and then each of the formal arguments is bound to a promise. The expression that was given for that formal argument and a pointer to the environment the function was called from are stored in the promise.

Until that argument is accessed there is no value associated with the promise. When the argument is accessed, the stored expression is evaluated in the stored environment, and the result is returned. The result is also saved by the promise.

source

A promise is therefore evaluated within the environment in which it was created (ie, the environment where the function was called), regardless of the environment in which the promise is first called. Observe:

delayedAssign("x", y)
local({
    y <- 10
    x
})  
Error in eval(expr, envir, enclos) : object 'y' not found

w <- 10
delayedAssign("z", w)
local({
    w <- 11
    z
})
[1] 10

Note that delayedAssign creates a promise. In the first example, x is assigned the value of y via a promise in the global environemnt, but y has not been defined in the global enviornment. x is called in an enviornment where y has been defined, yet calling x still results in an error indicating that y does not exist. This demonstrates that x is evaluated in environment in which the promise was defined, not in its current environment.

In the second example, z is assigned the value of w via a promise in the global environment, and w is defined in the global environment. z is then called in an enviornment where w has been assigned a different value, yet z still returns the value of the w in the environment where the promise has been created.

Upvotes: 3

nograpes
nograpes

Reputation: 18323

Although dprime exists in df.basic, when you call it at computeMeans it has no idea what you are referring to, unless you explicitly reference it.

computeMeans(df.basic,df.basic$dprime,mean)

will work.

Upvotes: 3

Related Questions