shouting versus dotting

[Janderson]

Andrei Alexandrescu wrote:
> dsimcha wrote:
>> == Quote from Andrei Alexandrescu (SeeWebsiteForEmail at erdani.org)'s 
>> article
>>> 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.
>>> Andrei
>>
>> Personally, I think that ".()" looks a little too much like a normal
>> function/method call.  The "!()" syntax looks just different enough to 
>> make it
>> easy to keep straight in my head that stuff with the "!" is a 
>> compile-time
>> construct and stuff without it can be evaluated at runtime.
> 
> I'm arguing we _should_ make template code look like "normal" code, 
> whatever "normal" is :o). We _should_ strive for "quiet" templates.
> 
> You know what annoys the living heebiejeebies out of me? Nested template 
> instantiations.
> 
> This!(That!(TheOther!(crap)))
> 
> I have a ton + change of those. In superdan's words: intercourse that.
> 
> 
> Andrei

I guess if you want to make template look like normal code your could 
look at extending that static syntax to accept things like alias:

void FooTemplate(alias T, alias T2, static T x, T2 f)
{
...
}


//call

int value;
FooTemplate(int, int, 10, value);

//And with induction T2 can be solved so (Note: I'm considering 
induction either all that can be solved, or nothing)
FooTemplate(int, 10, value);


-Joel