View mode: basic / threaded / horizontal-split · Log in · Help
October 10, 2008
Template instantiation syntax
We seem to have reached a dead end on finding a significantly better 
alternative than foo!(bar).

All is not lost, though. Andrei is working on an emacs module that will 
parse D code and replace foo!(bar) with foo«bar» for display only when 
the editor is in D mode, the underlying text will still be foo!(bar). 
(This doesn't affect D at all, only its display in Emacs.)

Also, we're going to try using ! for single argument syntax, as in:

foo!bar  is same as   foo!(bar)
foo!10   is same as   foo!(10)

etc. 0 arguments or more than 1 argument or arguments that are more than 
one token long will still require !( ). We'll see how that works. I 
think it looks rather nice.
October 10, 2008
Re: Template instantiation syntax
Fri, 10 Oct 2008 14:15:12 -0700,
Walter Bright wrote:
> Also, we're going to try using ! for single argument syntax, as in:
> 
> foo!bar  is same as   foo!(bar)
> foo!10   is same as   foo!(10)
> 
> etc. 0 arguments or more than 1 argument or arguments that are more than 
> one token long will still require !( ). We'll see how that works. I 
> think it looks rather nice.

I'd definitely give it a try.
October 10, 2008
Re: Template instantiation syntax
Walter Bright:
> Also, we're going to try using ! for single argument syntax, as in:
> foo!bar  is same as   foo!(bar)
> foo!10   is same as   foo!(10)

And what's the advantage of such special casing of the syntax? Just to remove 2 chars () that improves clarity? I am for using shorter syntaxes in D, but not in that way. If you want to reduce the length of D programs make the semicolons optional, introduce eager and lazy array comprehensions, try to introduce a lambda syntax like the C# one, etc.

Bye,
bearophile
October 10, 2008
Re: Template instantiation syntax
bearophile wrote:
> And what's the advantage of such special casing of the syntax? Just
> to remove 2 chars () that improves clarity?

Yes. I think small things like this can make a big difference. Most 
template instantiations are one simple argument.

> I am for using shorter
> syntaxes in D, but not in that way.

Why not?

> If you want to reduce the length
> of D programs make the semicolons optional,

That would seriously damage the compiler's ability to identify, 
diagnose, and recover from syntax errors correctly.

> introduce eager and lazy
> array comprehensions, try to introduce a lambda syntax like the C#
> one, etc.
October 10, 2008
Re: Template instantiation syntax
Walter Bright wrote:
> We seem to have reached a dead end on finding a significantly better 
> alternative than foo!(bar).
> 
> All is not lost, though. Andrei is working on an emacs module that will 
> parse D code and replace foo!(bar) with foo«bar» for display only when 
> the editor is in D mode, the underlying text will still be foo!(bar). 
> (This doesn't affect D at all, only its display in Emacs.)
> 
> Also, we're going to try using ! for single argument syntax, as in:
> 
> foo!bar  is same as   foo!(bar)
> foo!10   is same as   foo!(10)
> 
> etc. 0 arguments or more than 1 argument or arguments that are more than 
> one token long will still require !( ). We'll see how that works. I 
> think it looks rather nice.

Quick question: is "!" an operator in this context? (Or is it 
something-other-than-an-operator? If so, what is it?)

Is this code legal:

   (foo!bar)[] myArray;

Thanks!

--benji
October 10, 2008
Re: Template instantiation syntax
Walter Bright Wrote:

> We seem to have reached a dead end on finding a significantly better 
> alternative than foo!(bar).
> 
> All is not lost, though. Andrei is working on an emacs module that will 
> parse D code and replace foo!(bar) with foo«bar» for display only when 
> the editor is in D mode, the underlying text will still be foo!(bar). 
> (This doesn't affect D at all, only its display in Emacs.)
> 
> Also, we're going to try using ! for single argument syntax, as in:
> 
> foo!bar  is same as   foo!(bar)
> foo!10   is same as   foo!(10)
> 
> etc. 0 arguments or more than 1 argument or arguments that are more than 
> one token long will still require !( ). We'll see how that works. I 
> think it looks rather nice.

Couple of comments/questions

The tool!lathe syntax doesn't look visually distinct enough for me. The @ syntax seems nicer on the eyes. I'm not trying to push changes. @() looks ugly to me, and having matching template syntax is desirable.

Is it ok to chain!nested!templates?  Gramatically, it's unambiguous.

Will Andrei color template parameters with ! so they're easier to spot? How would they look when nested? Alternating colors should work
October 10, 2008
Re: Template instantiation syntax
Op Fri, 10 Oct 2008 23:29:00 +0200 schreef bearophile  
<bearophileHUGS@lycos.com>:

> If you want to reduce the length of D programs make the semicolons  
> optional, introduce eager and lazy array comprehensions, try to  
> introduce a lambda syntax like the C# one, etc.

If you could reduce the length of your whining it would save me alot of  
reading time aswell :-)
October 10, 2008
Re: Template instantiation syntax
Jason House wrote:
> Walter Bright Wrote:
> 
>> We seem to have reached a dead end on finding a significantly
>> better alternative than foo!(bar).
>> 
>> All is not lost, though. Andrei is working on an emacs module that
>> will parse D code and replace foo!(bar) with foo«bar» for display
>> only when the editor is in D mode, the underlying text will still
>> be foo!(bar). (This doesn't affect D at all, only its display in
>> Emacs.)
>> 
>> Also, we're going to try using ! for single argument syntax, as in:
>> 
>> 
>> foo!bar  is same as   foo!(bar) foo!10   is same as   foo!(10)
>> 
>> etc. 0 arguments or more than 1 argument or arguments that are more
>> than one token long will still require !( ). We'll see how that
>> works. I think it looks rather nice.
> 
> Couple of comments/questions
> 
> The tool!lathe syntax doesn't look visually distinct enough for me.
> The @ syntax seems nicer on the eyes. I'm not trying to push changes.
> @() looks ugly to me, and having matching template syntax is
> desirable.

I agree. But after all the aggravation, I learned to be happy with what
I can get.

> Is it ok to chain!nested!templates?  Gramatically, it's unambiguous.

Walter gave me a black eye over it last night. I'll let him to provide
the juicy details. The short version is that for now a!b!c is disallowed
with extreme prejudice.

> Will Andrei color template parameters with ! so they're easier to
> spot? How would they look when nested? Alternating colors should work

Walter exaggerated when he said that "I'm working on" an emacs solution.
I only said "I'm pretty sure it can be done". :o)


Andrei
October 10, 2008
Re: Template instantiation syntax
Walter Bright schrieb:
> We seem to have reached a dead end on finding a significantly better 
> alternative than foo!(bar).
> 
> All is not lost, though. Andrei is working on an emacs module that will 
> parse D code and replace foo!(bar) with foo«bar» for display only when 
> the editor is in D mode, the underlying text will still be foo!(bar). 
> (This doesn't affect D at all, only its display in Emacs.)
> 

So!Smalltalk inspired  :)  What about st like code blocks instead of 
closures ?
Would make code more readable then allowing ! instead of !()

> Also, we're going to try using ! for single argument syntax, as in:
> 
> foo!bar  is same as   foo!(bar)
> foo!10   is same as   foo!(10)
> 

Both valid than ?

> etc. 0 arguments or more than 1 argument or arguments that are more than 
> one token long will still require !( ). We'll see how that works. I 
> think it looks rather nice.
October 10, 2008
Re: Template instantiation syntax
Benji Smith wrote:
> Quick question: is "!" an operator in this context?

Yes.

> (Or is it 
> something-other-than-an-operator? If so, what is it?)
> 
> Is this code legal:
> 
>    (foo!bar)[] myArray;

Yes, just like:
     foo.bar[] myArray;
is legal.
« First   ‹ Prev
1 2 3 4 5
Top | Discussion index | About this forum | D home