Variable arguments should be included even when shorthand lists can serve the same purpose, as they increase intuitiveness and reduce errors.
[It is assumed that you agree with the acceptable “use” for a language function — that is intuitiveness and error reduction.]
I base this on a purely anecdotal experience using both of these functions in my own language of game scenarios and the observed learning curve and common mistakes made by users. [Users ranged from fresh schools to industry veterans in several multi-year projects over a decade and a half in different game companies - the largest with 160 team members (20 main script users + 50 or so script real -time “command line users”). Some of them were pure screenwriters who knew only this scripting language or a couple of others, and some of them were also experienced C ++ programmers - both groups seemed to have the same results on this issue.]
[If relevant, the language I'm based on has also typed variable arguments, and all types have a common base class.]
Over the years, I created several dual methods that were identical, although variable-length arguments were used, and the other was a list. Internally, both methods with different interfaces were reduced to the same code - they made up only the stylistic syntactic difference.
In the wild, I found that a mechanism using an abbreviated list with two additional characters means that there are only two other characters that you can forget. I base this on the number of times I was called in to “help” users who had problems with versioning of list-based methods, as opposed to variable argument methods.
As for intuitiveness, I did some profiling / counting methods, and the number of instances of using variable length methods significantly outweighed the list methods. Also, when asked, people seemed to aesthetically prefer variable versions of arg.
However, I still think that there is great utility in using list-based methods, especially when creating more complex calls and metaprograms, since it is convenient to process a bunch of arguments as a whole and the general functions of the list - intersection, union, filtering, etc. can also be used for arguments.
I very much believe that I will add only those functions that are necessary to reduce the amount that a given programmer should keep in mind at any time, although over the years I have found that a valid exception to this rule is sometimes guaranteed if the function is simpler to use or causes fewer errors. [The earlier scripting language I wrote was very optimized - and, in my opinion, was elegant, although I learned that people liked it more and had less problems with it as soon as I developed it to have a bit more “redundancy” in the name of intuitiveness and reduced errors.]
Obviously, different languages with different elements around these functions and different users and domains can have different results - although for what it's worth, I'm confidently based on how long I made my observations.
[Also]
Another potential specific difference between args and shorthand is whether the language can tell the difference between passing arguments in the arg variable to the method / function interface and arguments / operators used as elements in the shorthand.
If the parameter of the arg variable can indicate something higher and higher than what can be indicated for the shortened list (or vice versa) - that is, the arguments are passed by reference or by value, the arguments must use some kind of lazy evaluation or evaluated by a call, etc. .d. - then more can be done with one or the other syntax.
It really depends on the language, and there would be no difference if the arguments used by the variable argument "group" or the elements of the short list could be "passed" in the same way.