shouting versus dotting

[Ary Borenszweig]

Andrei Alexandrescu escribió:
> Tom S wrote:
>> Andrei Alexandrescu wrote:
>>>> ... It looks like it should yield a tuple containing bar and baz :P
>>>>
>>>>
>>>> foo!(bar, baz)   <-  distinct, no issue.
>>>
>>> Looks great until you have twenty or thirty of these on a code 
>>> screen. Then you're like, boy this is one ugly language. Believe me, 
>>> I *tried* to put up with it.
>>
>> Hm, I didn't think so when working on ctrace or Bind...
>> I could similarly say that parentheses look bad and we should change 
>> them to something else because a screenful of them looks ugly when 
>> calling lots of functions.
> 
> You couldn't because f(a, b) is already used in math for function
> invocation. "Word!" is already used. For shouting that is.
> 
>>>> I would not like to have compile-time and run-time merged visually 
>>>> in code.
>> This statement was likely misleading, sorry for that. I don't see it 
>> as a bad thing that some functions will be running at compile-time 
>> 'behind my back'. I just wouldn't like the visual distinction between 
>> normal function calls and template evaluations to go away as long as 
>> they are fundamentally different.
> 
> They are and they stay different. One oughtn't be shouting at you though.
> 
>>> You already do in template argument deduction.
>>
>> Point. But for a different purpose - eliminating a lot of redundant 
>> code and making some meta programming feasible. It's a bit different 
>> from pretending template evaluation is like function calls.
> 
> Well parens are already used for more than function calls and nobody
> seems to mind.
> 
>>> The times go against the style of coding that separates compile-time 
>>> stuff from run-time stuff.
>>
>> The times? I'd say that these times have already been ;) You may not 
>> have this distinction e.g. in Lisp. But if you consider that D only 
>> has one 'compile time', while you could freely operate on anything at 
>> any time in Lisp, it makes more sense to have the compile-time phase 
>> stand out a bit. Especially because template code is still very 
>> different than normal D code (it's functional and memoized, after 
>> all). I'd be tempted to change my mind here if D had more 
>> meta-facilities, but at the current state of things, I'd say that the 
>> 'times' are pretty stagnant for D.
> 
> More meta-facilities are coming D's way, not less. As far as Lisp is
> concerned, at least in Scheme (I forgot how you do it in Lisp) macro
> invocation isn't distinguished in any way. For example "and" in (and a b
> c) is a macro.
> 
>>>> Let's also keep in mind what Ary said, that using "." will cause 
>>>> problems for IDEs.
>>>
>>> No it won't.
>>
>> Would you elaborate on this? I'd rather believe Ary if nothing else is 
>> provided to your point. Ary is the creator of the most advanced IDE 
>> for D as far as I know.
> 
> A template name without arguments has no members, except inside the very
> template definition, when you'd rarely use it.

I don't think it's because of that, but the IDE could check that if 
what's before the "." is a template, suggest instantiation. So after 
thinking about it again, I agree with you that it won't be problematic.

Anyway, I don't like the .() syntax. :-P