dropping parentheses on template instantiation

[KennyTM~]

Ary Borenszweig wrote:
> 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

But :'( is ambiguous... :'(

(All of my suggestions, even though they're intentionally crap, do not 
coincide with existing syntax and cause ambiguities.)

Oh one more. If we allow -- to be binary we get the ink-saving solution

   Vector--Stack--Tuple--(Positive--real, Matrix--real--(3,3))

it looks like a spreadsheet header to me.


(OK Seriously I think a!b is good enough, and a{b} is better.)