On 19.01.19 17:36, Carl Sturtivant wrote:
> 
> Why is it that when template arguments are supplied at the point of use, the nice distinguishing syntax of x!(a,b,c) is obligatory, yet when template parameters are supplied at the point of definition the syntax is not distinguished in the same way with a bang !
> 
> 

There is no good reason why. It bothers me too.

On Sunday, 20 January 2019 at 12:35:58 UTC, Patrick Schluter wrote:
> On Saturday, 19 January 2019 at 22:52:25 UTC, Carl Sturtivant
>
> Afaik it's a parser problem. Walter wanted to avoid the catastrophic state that exist in C++ of an ambiguous grammar. He insited that the the grammar of the D language be as straightforward as can be.
> In the template declaration, both parenthesis pairs are required and the parser knows directly that first '(' == template parameter, second '(' rt parameter.
> At the instanciation site, it was preferred to have parameter inference, i.e. that the template parameter [1] can be omitted if it can be deduced from the runtime parameter. This has the consequence that the starting '(' becomes ambiguous, it can mean template parameter start or runtime parameter start. Using another operator allows to lift the ambiguity. Forcing to have parenthesis would also lift the ambiguity, but it would be at the cost of parameter inference as it would be impossible distinguish between infered parameter or no parameter. ! was chosen because it is light and its only use is in prefix context, in template instantiation it's in a infix position and thus completely unambiguous with the ! operator.
> [1]: https://tour.dlang.org/tour/en/basics/templates

You've given a more detailed version of a response given earlier.
https://forum.dlang.org/post/xypridqjaqxosnxaqbjm@forum.dlang.org

So my reply to that is also pertinent here.
https://forum.dlang.org/post/anlnnizkcohoznigynpj@forum.dlang.org

On Sunday, 20 January 2019 at 16:22:09 UTC, Carl Sturtivant wrote:
> On Sunday, 20 January 2019 at 12:35:58 UTC, Patrick Schluter wrote:
>> On Saturday, 19 January 2019 at 22:52:25 UTC, Carl Sturtivant
>>
>> Afaik it's a parser problem. Walter wanted to avoid the catastrophic state that exist in C++ of an ambiguous grammar. He insited that the the grammar of the D language be as straightforward as can be.
>> In the template declaration, both parenthesis pairs are required and the parser knows directly that first '(' == template parameter, second '(' rt parameter.
>> At the instanciation site, it was preferred to have parameter inference, i.e. that the template parameter [1] can be omitted if it can be deduced from the runtime parameter. This has the consequence that the starting '(' becomes ambiguous, it can mean template parameter start or runtime parameter start. Using another operator allows to lift the ambiguity. Forcing to have parenthesis would also lift the ambiguity, but it would be at the cost of parameter inference as it would be impossible distinguish between infered parameter or no parameter. ! was chosen because it is light and its only use is in prefix context, in template instantiation it's in a infix position and thus completely unambiguous with the ! operator.
>> [1]: https://tour.dlang.org/tour/en/basics/templates
>
> You've given a more detailed version of a response given earlier.
> https://forum.dlang.org/post/xypridqjaqxosnxaqbjm@forum.dlang.org

The point is that Walter Bright insists on context free grammar. This is a key point that allows for fast parsing. C++ is in the mess it is because it cannot be parsed (without heroic efforts). Every syntax choice has to abide by that rule. Template parameter inference was deemed MORE important than a slight inconsistency in the syntax of definition and use of the template. If that had not been the case, you would have to explicitely give always all type parameter in the template instanciation, every single time. This would make the code much more tedious, would violate DRY principle and would not even work properly as there are types in D that cannot even be written out (Voldemort types).
D would be so much less expressive because of that.
So, this slight inconsistency is a small price to pay for the benefits it provides.

>
> So my reply to that is also pertinent here.
> https://forum.dlang.org/post/anlnnizkcohoznigynpj@forum.dlang.org

On 20.01.19 17:34, Patrick Schluter wrote:
> On Sunday, 20 January 2019 at 16:22:09 UTC, Carl Sturtivant wrote:
>> On Sunday, 20 January 2019 at 12:35:58 UTC, Patrick Schluter wrote:
>>> On Saturday, 19 January 2019 at 22:52:25 UTC, Carl Sturtivant
>>>
>>> Afaik it's a parser problem. Walter wanted to avoid the catastrophic state that exist in C++ of an ambiguous grammar. He insited that the the grammar of the D language be as straightforward as can be.
>>> In the template declaration, both parenthesis pairs are required and the parser knows directly that first '(' == template parameter, second '(' rt parameter.
>>> At the instanciation site, it was preferred to have parameter inference, i.e. that the template parameter [1] can be omitted if it can be deduced from the runtime parameter. This has the consequence that the starting '(' becomes ambiguous, it can mean template parameter start or runtime parameter start. Using another operator allows to lift the ambiguity. Forcing to have parenthesis would also lift the ambiguity, but it would be at the cost of parameter inference as it would be impossible distinguish between infered parameter or no parameter. ! was chosen because it is light and its only use is in prefix context, in template instantiation it's in a infix position and thus completely unambiguous with the ! operator.
>>> [1]: https://tour.dlang.org/tour/en/basics/templates
>>
>> You've given a more detailed version of a response given earlier.
>> https://forum.dlang.org/post/xypridqjaqxosnxaqbjm@forum.dlang.org
> 
> The point is that Walter Bright insists on context free grammar. This is a key point that allows for fast parsing. C++ is in the mess it is because it cannot be parsed (without heroic efforts). Every syntax choice has to abide by that rule. Template parameter inference was deemed MORE important than a slight inconsistency in the syntax of definition and use of the template. If that had not been the case, you would have to explicitely give always all type parameter in the template instanciation, every single time. This would make the code much more tedious, would violate DRY principle and would not even work properly as there are types in D that cannot even be written out (Voldemort types).
> D would be so much less expressive because of that.
> So, this slight inconsistency is a small price to pay for the benefits it provides.

It provides zero benefits. The grammar is still as context free as before even if template declarations use consistent syntax, and the following lookahead becomes unnecessary, making parsing of function declarations simpler and more efficient:

https://github.com/dlang/dmd/blob/master/src/dmd/parse.d#L4123

It's just an annoying little design mistake. It happens.

I'm also not sure if you understood the OP. The suggestion is to have this consistent syntax:

void foo!(T)(T arg){ ... }
void bar!T(T arg){ ... }

instead of this inconsistent syntax:

void foo(T)(T arg) { ... }
void bar(T)(T arg) { ... }

The syntax at the call site is not being criticized.