On 6/30/2006 2:30 AM, Eric Lecoutre wrote:
> Hi Ben,
>
> I have often asked myself such question and often
> come back to the following additional options:
>
> (4) Use '...' and ensure encapsulated functions/calls (foo2 and foo3) also
> have '...' within their arguments. There is no problem to call 3dspehre with
>
> a list of arguments that include both 'radius' and 'size' if (and only if)
> 3dsphere
> function argumnts are (radius=,...) so that size will just be ignored.
>
> foo1 <- function(...){
> foo2(...)
> foo3(...)
> }
There are some problems with this approach (as there are problems with
all the other approaches; whether these matter is a matter of judgment):
- It may require you to modify foo2 and foo3. In this particular
instance, foo2 and foo3 are in a package, not under Ben's direct control.
- It breaks R's ability to warn you about typos. For example,
foo1(sz = 3)
would not cause an unrecognized parameter error; both functions would
accept and ignore the bad parameter setting.
- It breaks the partial argument matching, e.g.
foo1(siz = 3)
would act just like the above, instead of like
foo1(size = 3)
Duncan Murdoch
>
> Document that all arguments foo2 can handle could be
> introduced within a cool to foo1, as well as those foo3 arguments.
> Only problem/point of detail is case where foo2 and foo3 do share
> arguments and you would like to distinguish.
>
> Then use (5)
> foo1 <- function(x,foo2Args=list(radius=2), foo3Args=list(size), ...){
> do.call("foo2",foo2Args)
> # or do.call("foo2",c(foo2Args,list(...)) depending on what you prefer
> }
>
> Eric
>
>
> 2006/6/29, Ben Bolker <[EMAIL PROTECTED]>:
>>
>> I have a general style question about R coding.
>>
>> Suppose I'm writing a function (foo1) that calls other functions
>> (foo2, foo3, ...) which have complicated argument
>> lists (e.g. optim(), plot()), _and_
>> I may be calling several different functions in the body of
>> foo1. Since foo2 and foo3 have different sets of arguments, I
>> can't just use "..." ; I did write some code a while ago that
>> would look at formals() to dissect out arguments that should
>> be passed to the different functions, but it seemed overly
>> complex.
>>
>> The particular case I have now is a little simpler.
>>
>> foo2 (points3d) and foo3 (spheres3d)
>> are both functions from the rgl package
>> that pass arguments such as color, alpha, etc. along to
>> an rgl.material() command with lots of possible arguments.
>> (The function may also call segments3d or lines3d, but
>> these all have the same arguments as points3d.)
>> However, to change the size of points you use "size"; to
>> change the size of spheres you use "radius". Do I
>> (1) add "radius" to the argument list, cluttering up
>> the argument list for one particular special case?
>> (2) add "size" to the argument list, so that it doesn't
>> become part of "..." and I can say spheres3d(radius=size,...) ?
>> (3) do something like
>> dotlist = list(...)
>> if (type=="s" && !is.null(dotlist$size)) radius <- dotlist$size
>> and pull "size" out of ... myself (and make a note to that
>> effect in the documentation)?
>> (I guess another general solution to this is to ask for
>> lists of arguments, like MoreArgs in mapply(). Another
>> would be to go back and change spheres3d to make size
>> a synonym for radius ... )
>>
>> any thoughts?
>> Ben Bolker
>>
>>
>> --
>> 620B Bartram Hall [EMAIL PROTECTED]
>> Zoology Department, University of Florida http://www.zoo.ufl.edu/bolker
>> Box 118525 (ph) 352-392-5697
>> Gainesville, FL 32611-8525 (fax) 352-392-3704
>>
>> ______________________________________________
>> R-devel@r-project.org mailing list
>> https://stat.ethz.ch/mailman/listinfo/r-devel
>>
>
>
>
______________________________________________
R-devel@r-project.org mailing list
https://stat.ethz.ch/mailman/listinfo/r-devel
