So here's the way I'm reading this:
Original:
curry_call is the function body you're constructing, which is itself
just a one liner which calls the symbol FUN with the appropriate
substitutions.
call("function", [...]) calls the "function" function, which itself
takes 2 arguments: the list of formal args and the function body.
eval of this call returns the newly constructed function, which you
assign to f. Then you assign the parent.frame() as the environment of f,
except with the symbol FUN assigned as the original argument FUN.
However, upon looking at the debugger, I find that env$FUN<-FUN assigns
FUN in Global Scope if Curry is called from the top level.
A nested Curry call then creates FUN=function(...) FUN([...]), a
recursive infinite loop.
New:
The recursion is obviously removed now, but what's the new version do?
As far as I can tell, it returns a structure like...
function(...){function(...) {original_function_body(curried_arg, ...=...)}}
Comparing and contrasting to the version in "functional" package:
1) quotes work (can do Curry(quote(foo), 2) where the "functional"
version can't)
2) environment capture works in both constructions
3) Your new version is exceptionally transparent, as the function body
gets stored so that when you print the body later, you can see the original
As far as 0 argument functions, I understand the difference, that idea
came from a programming language (q/kdb+) I know that supports a neat
compact syntax for this:
Suppose in R the function was f(x,y,z) x + y + z
In q, one could do:
f[1;2] // returns the curried form
f[1;2] each (1 2 3 4 5) // equivalent to Map(function(z) f(1,2,z), 1:5)
or Map(Curry(f, 1, 2), 1:5)
f[1;2;3] // returns 6
f[1;2][3] // returns 6
Probably a slightly different but related concept - elided arguments,
just a curry with automatic eval when all argument slots are filled.
Thanks, this has been very enlightening.
Yike
On 5/25/2012 9:49 AM, Hadley Wickham wrote:
That's easily fixed:
Curry<- function(FUN, ...) {
args<- match.call(expand.dots = FALSE)$...
args$...<- as.name("...")
env<- parent.frame()
if (is.name(FUN)) {
fname<- FUN
} else if (is.character(FUN)) {
fname<- as.name(FUN)
} else if (is.function(FUN)){
fname<- FUN
# env$FUN<- FUN
} else {
stop("FUN not function or name of function")
}
curry_call<- as.call(c(list(fname), args))
f<- eval(call("function", as.pairlist(alist(... = )), curry_call))
environment(f)<- env
f
}
Curry(Curry(foo,3),4)
e.g.:
foo=function(x,y,z) x+y+z
Curry(Curry("foo",3),4)(3)
# 10
Curry(Curry(foo,3),4)(3)
# hangs
foo4=function(a,b,c,d)
Curry(Curry(Curry("foo4",3),4),1)(3)
# hangs
I was also curious if there was some trick to force a function eval when the
list of arguments got exhausted (for example, a triple Curry on foo above
would leave no arguments so would trigger eval into 10).
I don't think that would be a good idea - there's a big difference
between a function with no arguments and the result of calling that
function.
Hadley
______________________________________________
R-devel@r-project.org mailing list
https://stat.ethz.ch/mailman/listinfo/r-devel
