shouting versus dotting

[KennyTM~]

Ary Borenszweig wrote:
Ary Borenszweig wrote:
> Andrei Alexandrescu wrote:
>> Bill Baxter wrote:
>>> On Sun, Oct 5, 2008 at 1:06 PM, Andrei Alexandrescu
>>> <SeeWebsiteForEmail at erdani.org> 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'm joining this discussion late, but I just wanted to say the !()
>>> doesn't bother me so much.
>>> What Walter said to you was pretty much how it went for me.  Seemed
>>> weird for a while, but I got used to it.
>>>
>>> I had to do several double-takes reading this thread thinking people
>>> were suggesting to use plain "()" because the little dot is just so
>>> easy to miss.
>>>
>>> I find !() to at least be easier on the eyes than greater-than
>>> less-than everywhere in C++.
>>>
>>> I wouldn't be adamantly opposed to a different syntax, but it would
>>> have to be better by leaps and bounds for me to think it was worth the
>>> headache.  And .() doesn't seem leaps and bounds better to me.
>>>
>>> I suggest, though, that if you think it looks a lot better you should
>>> at least post some example code showing "before" and "after" to try to
>>> convince us.  Seems like not many here see a lot of point in making
>>> the change, so rather than pleading with everyone to try it out on
>>> their own, why not just save us the effort and show us how it improves
>>> the code you're looking at?
>>
>> Well part of the problem is that many people made up their mind just 
>> by imagining how it would look like, and it would be hard to sway them.
>>
>> Since you asked, here are some examples copied verbatim from a source 
>> file I found handy:
>>
>> alias DenseMatrix.(num) PulType;
>> alias SparseRowsMatrix.(num, HashSparseVector) PuuType;
>> alias BiMap.(uint, Tuple.(uint, uint), BiMapOptions.lhDense) DicType;
>>
>> For functions:
>>
>> sort.("a._0 == b._0 ? a._1 < b._1 : a._0 < b._0")(all);
>> result.id = std.conv.parse.(uint)(line);
>>
>> I was even more pleased while actually using The Sad Pirate than while 
>> imagining how it would be like, probably because typing is also easier 
>> (something that's not self-evident when just looking at the code).
>>
>> It looks like The Sad Pirate won't make it. People just don't see it 
>> as bringing enough improvement. But I think it is worth pursuing a 
>> number of alternatives. The two that to me are the most appealing are:
>>
>> a) Template{Args}
>>
>> Experience with Perl has shown that using {} as parens in addition to 
>> blocks is easy to pick up and easy on the eyes. Another argument in 
>> favor is that {} are "the right thing" - meaning they are parens that 
>> pair properly, as opposed to "<>". Also, they make today's "!()" look 
>> like a contraption that creates a new kind of parens from an existing 
>> (and ambiguous) kind of parens by prefixing it with a marker.
>>
>> b) Template at Arg and Template@(Args)
>>
>> This approach not only accepts the need for a contraption, it actually 
>> leverages it by allowing you to drop the parens if you only have one 
>> argument. That way "@" becomes a true operator, the template 
>> instantiation operator. Note that this can be done with the current 
>> "!" as well, except that Template!Arg does not look to me like 
>> anything enticing.
> 
> So let's have them written down to be able to compare them easier:
> 
> The sad pirate
> ----------------
> 
> alias DenseMatrix.(num) PulType;
> alias SparseRowsMatrix.(num, HashSparseVector) PuuType;
> alias BiMap.(uint, Tuple.(uint, uint), BiMapOptions.lhDense) DicType;
> 
> The curly braces
> ----------------
> 
> alias DenseMatrix{num} PulType;
> alias SparseRowsMatrix{num, HashSparseVector} PuuType;
> alias BiMap{uint, Tuple{uint, uint}, BiMapOptions.lhDense} DicType;
> 
> The at
> ----------------
> 
> alias DenseMatrix at num PulType;
> alias SparseRowsMatrix@(num, HashSparseVector) PuuType;
> alias BiMap@(uint, Tuple@(uint, uint), BiMapOptions.lhDense) DicType;
> 
> ---
> 
> Personally, I find the {} easier to understand, and it's less typing, 
> but it doesn't allow to omit the closing } for one argument.
> 
>>
>>
>> Andrei

> Andrei Alexandrescu wrote:
>> Bill Baxter wrote:
>>> On Sun, Oct 5, 2008 at 1:06 PM, Andrei Alexandrescu
>>> <SeeWebsiteForEmail at erdani.org> 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'm joining this discussion late, but I just wanted to say the !()
>>> doesn't bother me so much.
>>> What Walter said to you was pretty much how it went for me.  Seemed
>>> weird for a while, but I got used to it.
>>>
>>> I had to do several double-takes reading this thread thinking people
>>> were suggesting to use plain "()" because the little dot is just so
>>> easy to miss.
>>>
>>> I find !() to at least be easier on the eyes than greater-than
>>> less-than everywhere in C++.
>>>
>>> I wouldn't be adamantly opposed to a different syntax, but it would
>>> have to be better by leaps and bounds for me to think it was worth the
>>> headache.  And .() doesn't seem leaps and bounds better to me.
>>>
>>> I suggest, though, that if you think it looks a lot better you should
>>> at least post some example code showing "before" and "after" to try to
>>> convince us.  Seems like not many here see a lot of point in making
>>> the change, so rather than pleading with everyone to try it out on
>>> their own, why not just save us the effort and show us how it improves
>>> the code you're looking at?
>>
>> Well part of the problem is that many people made up their mind just 
>> by imagining how it would look like, and it would be hard to sway them.
>>
>> Since you asked, here are some examples copied verbatim from a source 
>> file I found handy:
>>
>> alias DenseMatrix.(num) PulType;
>> alias SparseRowsMatrix.(num, HashSparseVector) PuuType;
>> alias BiMap.(uint, Tuple.(uint, uint), BiMapOptions.lhDense) DicType;
>>
>> For functions:
>>
>> sort.("a._0 == b._0 ? a._1 < b._1 : a._0 < b._0")(all);
>> result.id = std.conv.parse.(uint)(line);
>>
>> I was even more pleased while actually using The Sad Pirate than while 
>> imagining how it would be like, probably because typing is also easier 
>> (something that's not self-evident when just looking at the code).
>>
>> It looks like The Sad Pirate won't make it. People just don't see it 
>> as bringing enough improvement. But I think it is worth pursuing a 
>> number of alternatives. The two that to me are the most appealing are:
>>
>> a) Template{Args}
>>
>> Experience with Perl has shown that using {} as parens in addition to 
>> blocks is easy to pick up and easy on the eyes. Another argument in 
>> favor is that {} are "the right thing" - meaning they are parens that 
>> pair properly, as opposed to "<>". Also, they make today's "!()" look 
>> like a contraption that creates a new kind of parens from an existing 
>> (and ambiguous) kind of parens by prefixing it with a marker.
>>
>> b) Template at Arg and Template@(Args)
>>
>> This approach not only accepts the need for a contraption, it actually 
>> leverages it by allowing you to drop the parens if you only have one 
>> argument. That way "@" becomes a true operator, the template 
>> instantiation operator. Note that this can be done with the current 
>> "!" as well, except that Template!Arg does not look to me like 
>> anything enticing.
> 
> So let's have them written down to be able to compare them easier:
> 
> The sad pirate
> ----------------
> 
> alias DenseMatrix.(num) PulType;
> alias SparseRowsMatrix.(num, HashSparseVector) PuuType;
> alias BiMap.(uint, Tuple.(uint, uint), BiMapOptions.lhDense) DicType;
> 
> The curly braces
> ----------------
> 
> alias DenseMatrix{num} PulType;
> alias SparseRowsMatrix{num, HashSparseVector} PuuType;
> alias BiMap{uint, Tuple{uint, uint}, BiMapOptions.lhDense} DicType;
> 
> The at
> ----------------
> 
> alias DenseMatrix at num PulType;
> alias SparseRowsMatrix@(num, HashSparseVector) PuuType;
> alias BiMap@(uint, Tuple@(uint, uint), BiMapOptions.lhDense) DicType;
> 
> ---
> 
> Personally, I find the {} easier to understand, and it's less typing, 
> but it doesn't allow to omit the closing } for one argument.
> 
>>
>>
>> Andrei

I don't think being able to omit {} is a big problem. Well, we used f(x) 
in a function with 1 parameter so long without complaining anyway.

(Some mathematicians use f`1 to indicate f(1) to avoid confusion with 
multiplication; and many cases the ( ) are even omitted, e.g. sin 1. So 
f(x) is not "the" norm.)