Solving the impossible?

[Everlast]

On Tuesday, 28 August 2018 at 19:40:36 UTC, Paul Backus wrote:
> On Tuesday, 28 August 2018 at 19:09:38 UTC, Everlast wrote:
>> Yeah, I see the link paul posted. The actual syntax seems a 
>> bit strange to me...
>>
>> We don't do
>>
>> A[] a ....
>>
>> So it is not "logical".
>>
>> foo(A...)(A a)
>>
>> but if A is a specific type we must do
>>
>> foo(int[] a ...)
>>
>> The actual syntax then looks like we have an variadic set of 
>> parameters of type int[] rather than int.
>
> In `foo(A...)(A a)`, a variadic set of template *arguments* is 
> collected into a single template *parameter*, called `A`. In 
> `foo(int[] a ...)`, a variadic set of runtime *arguments* is 
> collected into a single runtime *parameter* called `a`.
>
> (If you've used Python, it's also similar to how `*args` and 
> `**kwargs` collect variadic positional and named arguments into 
> a single list or dictionary parameter, respectively.)
>
> It really is the same underlying principle in both cases. It 
> just looks different because `foo(A...)(A a)` is a template, 
> and `foo(int[] a...)` isn't, and templates use a different 
> syntax than regular functions.
>
> In fact, if you wanted to, you could combine the two and do 
> something like this:
>
>     // All args must have the same type,
>     // but it can be any type you want.
>     foo(T)(T[] t...)


Yes, it is the same underlying principle but it is not visually 
consistent IMO.

e.g.,

foo(int[] a)

a is an array of int

foo(int[] a...)

suggests a is an array of an array of int.

I see ... as a generalization of the parameters simply extending 
it to an arbitrary number(which cannot be represented except in 
an arbitrary way).

so

a... means there is an arbitrary number of a's.

int a... means there is an arbitrary number of int.

T a... means there is an arbitrary number of T's

T[] a... means there is an arbitrary number of T[]'s.


For example, to represent an arbitrary number of arrays using the 
current syntax one must do T[][] a...

which looks funky.

Now, it's all not a big deal in the sense that it all works out 
by design, but the question is, is it really needed? It seems 
that requiring [] just adds extra unnecessary symbols that add no 
useful information.


Also, the biggest complaint is that when we use [] attached to a 
type it has a specific meaning as "an array of". e.g., int[] 
means an array of int's.

But int[] a... then changes as we don't have an array of int's 
any more but simply a sequence of ints. While internally it might 
not matter it just doesn't jive with normal type syntax IMO.

int[] a...

vs

int a...

the second one seems better. Simpler, more direct, more obvious, 
and inline with the standard non variadic syntax. The ellipses 
pretty much state that we are dealing with an array, no reason to 
add redundancy.

I'm only talking about syntax here and not semantics.

Of course, if you see a problem with int a... not being 
well-formed then that would be a case against it, but I don't 
think it has that issue.