[R-pkg-devel] R feature suggestion: Duplicated function arguments check

[Avi Gross]

Duncan,

This may not be the place to discuss this so I will be brief.

The question is whether it should be some kind of error to call a function
with two named arguments that are the same.

I can think of a perhaps valid use when a function expects to take the first
few arguments for personal use and then uses ... to pass the rest along to
other functions it calls.

so in your case, slightly extended:

	f(a=1, b=2, a=3, c=-5)

The function might pass along to another function:
	other(arg, ...)
which would be seen as:
	other(arg, a=3, c=-5)

There can of course be other ways to get this result but probably not as
simple. And note this can go several layers deep as various functions call
each other and each has a different need and even meaning for a=something.

Avi
-----Original Message-----
From: R-package-devel <r-package-devel-bounces using r-project.org> On Behalf Of
Duncan Murdoch
Sent: Monday, November 8, 2021 11:04 AM
To: Vincent van Hees <vincentvanhees using gmail.com>;
r-package-devel using r-project.org
Subject: Re: [R-pkg-devel] R feature suggestion: Duplicated function
arguments check

On 08/11/2021 10:29 a.m., Vincent van Hees wrote:
> Not sure if this is the best place to post this message, as it is more 
> of a suggestion than a question.
> 
> When an R function accepts more than a handful of arguments there is 
> the risk that users accidentally provide arguments twice, e.g 
> myfun(A=1, B=2, C=4, D=5, A=7), and if those two values are not the 
> same it can have frustrating side-effects. To catch this I am planning 
> to add a check for duplicated arguments, as shown below, in one of my 
> own functions. I am now wondering whether this would be a useful 
> feature for R itself to operate in the background when running any R 
> function that has more than a certain number of input arguments.
> 
> Cheers, Vincent
> 
> myfun = function(...) {
>    #check input arguments for duplicate assignments
>    input = list(...)
>    if (length(input) > 0) {
>      argNames = names(input)
>      dupArgNames = duplicated(argNames)
>      if (any(dupArgNames)) {
>        for (dupi in unique(argNames[dupArgNames])) {
>          dupArgValues = input[which(argNames %in% dupi)]
>          if (all(dupArgValues == dupArgValues[[1]])) { # double 
> arguments, but no confusion about what value should be
>            warning(paste0("\nArgument ", dupi, " has been provided 
> more than once in the same call, which is ambiguous. Please fix."))
>          } else { # double arguments, and confusion about what value 
> should be,
>            stop(paste0("\nArgument ", dupi, " has been provided more 
> than once in the same call, which is ambiguous. Please fix."))
>          }
>        }
>      }
>    }
>    # rest of code...
> }
> 

Could you give an example where this is needed?  If a named argument is
duplicated, R will catch that and give an error message:

   > f(a=1, b=2, a=3)
   Error in f(a = 1, b = 2, a = 3) :
     formal argument "a" matched by multiple actual arguments

So this can only happen when it is an argument in the ... list that is
duplicated.  But usually those are passed to some other function, so
something like

   g <- function(...) f(...)

would also catch the duplication in g(a=1, b=2, a=3):

   > g(a=1, b=2, a=3)
   Error in f(...) :
     formal argument "a" matched by multiple actual arguments

The only case where I can see this getting by is where you are never using
those arguments to match any formal argument, e.g.

   list(a=1, b=2, a=3)

Maybe this should have been made illegal when R was created, but I think
it's too late to outlaw now:  I'm sure there are lots of people making use
of this.

Or am I missing something?

Duncan Murdoch

______________________________________________
R-package-devel using r-project.org mailing list
https://stat.ethz.ch/mailman/listinfo/r-package-devel