dropping parentheses on template instantiation

[Ary Borenszweig]

KennyTM~ wrote:
> KennyTM~ wrote:
>> Ary Borenszweig wrote:
>>> Andrei Alexandrescu escribió:
>>>> Denis Koroskin wrote:
>>>>> On Sun, 05 Oct 2008 22:18:26 +0400, Andrei Alexandrescu 
>>>>> <SeeWebsiteForEmail at erdani.org> wrote:
>>>>>
>>>>>> I just realized something different. After making an informal 
>>>>>> review of some code, I saw that a large percentage of template 
>>>>>> instantiations only need ONE argument.
>>>>>>
>>>>>> This makes me think, with the old "!" notation, parentheses could 
>>>>>> be dropped entirely without prejudice:
>>>>>>
>>>>>> auto covariance = Matrix!real(n, n);
>>>>>> auto normalized = SparseVector!double(n);
>>>>>>
>>>>>> and so on.
>>>>>>
>>>>>> To the unbridled joy of the enemies of the Sad Pirate, the dot 
>>>>>> won't work for template instantiation because without the 
>>>>>> parentheses it DOES engender ambiguity.
>>>>>>
>>>>>> Now say we take the following route:
>>>>>>
>>>>>> 1) We find something different from shouting
>>>>>>
>>>>>> 2) We drop the parentheses for 1 argument
>>>>>>
>>>>>> That sounds like a possible winner. In this case the "#" becomes 
>>>>>> considerably more attractive, in fact very attractive exactly 
>>>>>> because it looks unlike any letter:
>>>>>>
>>>>>> auto covariance = Matrix#real(n, n);
>>>>>> auto normalized = SparseVector#double(n);
>>>>>>
>>>>>> Ideas?
>>>>>>
>>>>>>
>>>>>> Andrei
>>>>>>
>>>>>> P.S. The Sad Pirate is the emoticon
>>>>>>
>>>>>> .(
>>>>>>
>>>>>> It doesn't have an eye and is sad, too.
>>>>>
>>>>> Just to clarify things: Do you propose moving the first template 
>>>>> argument outside of the parentheses *or* ditching them iff there is 
>>>>> only one parameter? I mean, what does the original code look like, 
>>>>> because there is ambiguaty in your statement (to me):
>>>>
>>>> Ditch parens if there's only one argument. In that case the extra 
>>>> character becomes an enabling asset, not a liability.
>>>>
>>>>> const int n = 42;
>>>>> auto covariance = Matrix!(real, n, n); <-> auto covariance = 
>>>>> Matrix#real(n,n);
>>>>>
>>>>> *or*
>>>>>
>>>>> auto covariance = Matrix!(real)(n, n); <-> auto covariance = 
>>>>> Matrix#real(n,n);
>>>>
>>>> The latter.
>>>>
>>>>> Other than that Vector at real or Vector#real both sound good!
>>>>
>>>> I agree. In fact "Vector at real" sounds like a good way of talking 
>>>> about templates instead of "Vector instantiated with real". One 
>>>> reason for which I think "this" is a poor choice (as opposed to e.g. 
>>>> "self") is that it's very hard to talk about it.
>>>
>>> I like Vector at real. Also: HashMap@(Key, Value) looks nice to me. The 
>>> only thing is that in spanish keboards, I have to do alt-gr + Q to 
>>> get one @ :-P
>>
>> It seems that
>>
>> Stack!int
>> Stack at int
>> Stack#int
>>
>> are the only choices we're left with. All others are either binary 
>> operators, delimiters or some kind of parenthesis. But frankly 
>> speaking all of these characters are not very pretty :/
> 
> I suddenly realized you could use digraphs too.
> 
>   Vector::Stack::Tuple::(Positive::real, Matrix::real::(3,3))
> 
>   Vector->Stack->Tuple->(Positive->real, Matrix->real->(3,3))
> 
>   Vector<>Stack<>Tuple<>(Positive<>real, Matrix<>real<>(3,3))
> 
>   Vector.~Stack.~Tuple.~(Positive.~real, Matrix.~real.~(3,3))
> 
>   Vector\\Stack\\Tuple\\(Positive\\real, Matrix\\real\\(3,3))
> 
>   Vector^^Stack^^Tuple^^(Positive^^real, Matrix^^real^^(3,3))
> 
> whatever. (These examples should not be taken seriously, but please 
> don't restrict to only one character.)

If you take off the restriction of one character, I'd suggest two ways 
of doing it:

Vector:-)int:-)

for those who really like templates, and:

Vector:'(int:'(

for those who are scared of them, don't understand them, don't like 
them, etc.

                                                          ... like me