shouting versus dotting

[Andrei Alexandrescu]

Alexander Pánek wrote:
> Andrei Alexandrescu wrote:
>> Alexander Pánek wrote:
>>> Andrei Alexandrescu wrote:
>>>> The problem I see with "!" as a template instantiation is not 
>>>> technical. I write a fair amount of templated code and over years 
>>>> the "!" did not grow on me at all. I was time and again consoled by 
>>>> Walter than one day that will happen, but it never did. I also 
>>>> realized that Walter didn't see a problem with it because he writes 
>>>> only little template code.
>>>>
>>>> I didn't have much beef with other oddities unique to D. For 
>>>> example, I found no problem accommodating binary "~" and I was 
>>>> wondering what makes "!" different. I was just looking at a page 
>>>> full of templates and it looked like crap.
>>>>
>>>> One morning I woke up with the sudden realization of what the 
>>>> problem was: the shouting.
>>>>
>>>> In C, "!" is used as a unary operator. That may seem odd at first, 
>>>> but it nevers follows a word so it's tenuous to associate it with 
>>>> the natural language "!". In D, binary "!" _always_ follows a word, 
>>>> a name, something coming from natural language. So the conotation 
>>>> with exclamation jumps at you.
>>>>
>>>> That's why I find the choice of "!" poor. I believe it can impede to 
>>>> some extent acquisition of templates by newcomers, and conversely I 
>>>> believe that using .() can make templates more palatable. I tried 
>>>> using ".()" in my code and in only a couple of days it looked and 
>>>> felt way better to me. Based on that experience, I suggest that 
>>>> "!()" is dropped in favor of ".()" for template instantiation for D2.
>>>>
>>>> Sean's argument that "The exclamation mark signifies an assertion of 
>>>> sorts" is exactly where I'd want templates not to be: they should be 
>>>> blended in, not a hiccup from normal code. Serious effort has been, 
>>>> and still is, made in D to avoid shell-shocking people about use of 
>>>> templates, and I think ".()" would be a good step in that direction.
>>>
>>> Sean has a point. Templates are not runtime constructs. So a clear 
>>> distinction between instantiating a function with a given type and 
>>> just calling a function that has fixed argument types and a fixed 
>>> return type  is necessary.
>>
>> Why? This sounds objective, so you better back it up. Au contraire, I 
>> see absolutely, but absolutely no need for a distinction. If it 
>> weren't for syntactic difficulties, to me using straight parentheses 
>> for template instantiation would have been the perfect choice. (How 
>> many times did you just forget the "!"? I know I often do. Why? 
>> Because most of the time it's not even needed.)
>>
>>> The exclamation mark gives us this clear distinction and has served 
>>> well in terms of readability for me, especially because it jumps out 
>>> — not because it’s an exclamation mark, thus having a meaning in 
>>> natural language, but rather just because of its form. A straight 
>>> vertical line with a dot underneath it. That just works perfectly 
>>> well as seperator between identifier/type and type argument.
>>
>> I believe the clear distinction is not only unnecessary, but 
>> undesirable. We should actively fight against it.
> 
> IMHO — I forgot that before, so that’s why it might have sounded a bit 
> too objective —, the clear distinction is important to keep the code 
> self-documenting. It might not be so important in terms of freestanding 
> templated functions that might even be simple enough that the argument 
> types can be infered, but as soon as something heavily alters the way 
> the code and the binary looks like afterwards (CTFE, multiple templated 
> class/struct/function instantiates, string mixins created by CTFE 
> functions, etc.), it (again, in my truly subjective opinion) deserves to 
> be marked as such.
> 
> I see this distinction as feature, not as flaw.

I don't understand this argument. For one thing, argument type deduction 
for template functions is not simple at all and we're glad that it's 
taken care of.

Andrei