shouting versus dotting

[Sean Kelly]

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.

I like being able to distinguish between the function signature and the 
parameter list and to tell at a glance what's actually happening.  Since 
the dot already has a function in this context, I don't think it should 
be given another.  Also, if we get the option to override opDot, things 
could get really weird if it's also a template signifier.

>> 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.

Why is it undesirable?  I like the idea of static parameters as 
described at the conference last year, but I don't think that has any 
bearing on this particular issue.


Sean