Thanks a lot Hadley, think I got it figured out now.

expr <- substitute(
     myFoo <- function(
         myArg=0
     ){
         print("hello world!")
         eval(BODY)
         if("..." %in% names(formals(as.character(sys.call())[1]))){
             print(data.frame(...))
         } else {
             print("extended arguments not available yet.")
         }
     },
     list(BODY=x.body)
)
eval(expr)
myFoo()
myFoo(myArg=100)
formals(myFoo)
formals(myFoo) <- c(formals(myFoo), formals(data.frame))
formals(myFoo)
myFoo()
myFoo(myArg=100)
myFoo(a=1:5, b=1:5, myArg=100)
eval(call("myFoo", a=1:5, b=1:5))
do.call("myFoo", args=list(a=1:5, b=1:5))

One more question: is it possible to "augment" a function's body as I 
did with the function's arguments?
If there'd be a method that coerces objects of class "list" to class "{" 
and 'body()' would allow assignments of that class, you could run 
something like:

body(myFoo) <- as.curlyBracket(append(as.list(body(myFoo)), 
list(expression(eval(print("blabla"))))))

But I guess there isn't. Enough with playing around ;-)

Thanks,
Janko


On 26.05.2011 18:08, Hadley Wickham wrote:
> I think for the case where you want to built up a call from a function
> name + list of arguments, it's best to use call or as.call:
>
> call("f", a = 1, b = 2, c = 3)
>
> or if you already have the list:
> l<- list(as.name("f"), a = 1, b = 2, c = 3)
> as.call(l)
>
> Hadley
>
> On Thu, May 26, 2011 at 10:15 AM, Janko Thyson
> <janko.thyson.rstuff@googlemail.com>  wrote:
>> Dear List,
>>
>> just out of pure curiosity: is it possible to define a function via
>> 'substitute()' such that the function's formal arguments are specified by a
>> "wildcard" that is substituted when the expression is evaluated?
>>
>> Simple example:
>>
>> x.args<- formals("data.frame")
>> x.body<- expression(
>>     out<- myArg + 100,
>>     return(out)
>> )
>>
>> expr<- substitute(
>>     myFoo<- function(
>>         ARGS,
>>         myArg
>>     ){
>>         print("hello world!")
>>         print(ARGS)
>>         eval(BODY)
>>
>>     },
>>     list(ARGS=x.args, BODY=x.body)
>> )
>>
>> eval(expr)
>> myFoo(myArg=5)
>> # works
>>
>> myFoo(a=1:3, stringsAsFactors=FALSE, myArg=5)
>> # does not work
>>
>> It works for wildcard 'BODY' in the function's body, but not for wildcard
>> 'ARGS' in the argument definition part of the function definition.
>>
>> I thought that when writing a function that depends on some other function
>> like 'data.frame()', it would maybe be possible not to 'hardcode' the formal
>> arguments of 'data.frame()' in the new function def but to have it mapped
>> somewhat dynamically so that when 'data.frame()' changes, the new function
>> would change as well. This is probably a bad idea for countless reasons,
>> nevertheless I'd be interested in learning if it's possible at all ;-)
>>
>> TIA,
>> Janko
>>
>> ______________________________________________
>> R-devel@r-project.org mailing list
>> https://stat.ethz.ch/mailman/listinfo/r-devel
>>
>
>


-- 
------------------------------------------------------------------------

*Janko Thyson*
janko.thyson@googlemail.com <mailto:janko.thyson@googlemail.com>

Jesuitenstraße 3
D-85049 Ingolstadt

Mobile: +49 (0)176 83294257

This e-mail and any attachment is for authorized use by the intended
recipient(s) only. It may contain proprietary material, confidential
information and/or be subject to legal privilege. It should not be
copied, disclosed to, retained or used by any other party.
If you are not an intended recipient then please promptly delete this
e-mail and any attachment and all copies and inform the sender.


	[[alternative HTML version deleted]]

