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

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 at r-project.org> On Behalf Of
Duncan Murdoch
Sent: Monday, November 8, 2021 11:04 AM
To: Vincent van Hees <vincentvanhees at gmail.com>;
r-package-devel at r-project.org
Subject: Re: [R-pkg-devel] R feature suggestion: Duplicated function
arguments check

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