foo!(bar) ==> foo{bar} ==> foo[bar] (just Brackets)

[Bill Baxter]

On Sat, Oct 18, 2008 at 6:59 AM, Robert Fraser
<fraserofthenight at gmail.com> wrote:
> Don wrote:
>>
>> Bruno Medeiros wrote:
>>>
>>> Jason House wrote:
>>>>
>>>> Bruno Medeiros wrote:
>>>>
>>>>> Don wrote:
>>>>>>
>>>>>> Denis Koroskin wrote:
>>>>>>>
>>>>>>> On Wed, 08 Oct 2008 18:22:21 +0400, superdan <super at dan.org> wrote:
>>>>>>>
>>>>>>>> Walter Bright Wrote:
>>>>>>>>
>>>>>>>>> Dee Girl wrote:
>>>>>>>>>>
>>>>>>>>>> I did not follow this group recent. School started. Sorry! I just
>>>>>>>>>> see now and please add my vote if possible. I start with D recent
>>>>>>>>>> and I remember beginning. foo!(bar) was not pleasant. Like forced
>>>>>>>>>> convention with a bad char. And friends I show code never like it.
>>>>>>>>>> It is first thing they say why they do not like D. For me foo{bar}
>>>>>>>>>> better idea. Thank you, Dee Girl
>>>>>>>>>
>>>>>>>>> What do your friends think of { } ?
>>>>>>>>
>>>>>>>> School started. Every one so busy now. But I think does not matter
>>>>>>>> any more ^_^
>>>>>>>>
>>>>>>>> I want to make little idea. Sorry if idea mentioned before (I did
>>>>>>>> not
>>>>>>>> read every thread). I think we can look square brackets []. Let me
>>>>>>>> explain why.
>>>>>>>>
>>>>>>>> Paren () is over used in C and in D. Any expression can be in ().
>>>>>>>> And
>>>>>>>> adding () is possible in many cases. But it is not same with []. For
>>>>>>>> example a:(b) is ambiguous but a:[b] is not. So there are many signs
>>>>>>>> possible after symbol and before [. They are:
>>>>>>>>
>>>>>>>> ~ ! @ # $ % ^ & * - + = | \ / , < . > ? :
>>>>>>
>>>>>> Not all of them work. Here's a few examples:
>>>>>>
>>>>>>    enum { d= 3, e = 7 }
>>>>>>    int [] a=[1,2];
>>>>>>    bool c;
>>>>>>    auto k=[e]; // kills =
>>>>>>    a ~= c?[d]:[e]; // kills ?
>>>>>>    int [] f = c?k:[e]; // kills :
>>>>>>    if (f>[e]) {}   // kills <
>>>>>>    if (f<[e]) {}   // kills >
>>>>>>    auto g = (k,[d]); // kills comma
>>>>>>    auto h = k~[d]; // kills ~
>>>>>>
>>>>>> Array ops will kill + - * / & | % ^
>>>>>> Suddenly the list looks pretty short.
>>>>>> !@#$\.
>>>>>
>>>>> Hum, what about brackets without any prefix character at all?
>>>>>
>>>>>   Vector[int, 2] foo;
>>>>>   List[Vector[int, 2]] bar;
>>>>>   int[3] a = [1, 2, 3]; // array literal here
>>>>>   int[int] map;
>>>>>   alias DenseMatrix[num] PulType;
>>>>>   alias SparseRowsMatrix[num, HashSparseVector] PuuType;
>>>>>   alias BiMap[uint, Tuple[uint, uint], BiMapOptions.lhDense] DicType;
>>>>>   int var = a[2]; // array indexing here
>>>>>
>>>>> Hum... doesn't look bad visually. In fact it seems to fit quite nice
>>>>> with how associative arrays, and even normal arrays, are declared. Hum,
>>>>> yes, I'm personally liking this a lot.
>>>>>
>>>>> But does it have any ambiguities? Hum, can't think of any off-hand. If
>>>>> an identifier appears before a bracket list, it could either be a
>>>>> template instantiation, or an array indexation. But the syntax of both
>>>>> is the same, so it doesn't need to be distinguished in the parser.
>>>>>
>>>>> Waddya think, was this discussed before?
>>>>>
>>>>
>>>>
>>>> It may be easy to parse, but it isn't easy to read.
>>>>
>>>> What is goban[19]?  Is it an array or a template?  I'd hate to be
>>>> reading
>>>> through somebody else's code and have to decipher what things mean.
>>>
>>> I give the same answer I gave to Bill:
>>>
>>> True, you'd have to follow /goban/ to find out. But that is just a hover
>>> of the mouse away. :)
>>>
>>>
>>> Just for the record, I'm also not bothered by !(), but if some people
>>> really find the urge to change it, I'd much rather have brackets than the
>>> ugly sad pirate. I say ugly because the dot is much more common than the
>>> '!', and for me it has a more solidified meaning of accessing members, so
>>> seeing it used as part of the template instantiation syntax looks weird.
>>>
>> That's my opinion, too.
>>
>> Using square brackets would certainly fit with Walter's goal of making
>> templates less threatening for newcomers.
>> It would be pretty cool to teach a newbie:
>>
>> int[] a;
>> int[double] b;  // this is an AA
>> priorityqueue[double] c; // this is a template
>
> I can't tell if you're being sarcastic here or not...

I couldn't tell either.  To me sounds about as cool as having to teach
C newbies about all the different meanings of "static".

--bb