[Rd] advice on arguments

[Duncan Murdoch]

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 <bolker at zoo.ufl.edu>:
>>
>>    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                            bolker at zoo.ufl.edu
>> 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 at r-project.org mailing list
>> https://stat.ethz.ch/mailman/listinfo/r-devel
>>
> 
> 
>