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 | ||||
---|---|---|---|---|
| ||||
Posted in reply to Walter Bright | 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 | ||||
---|---|---|---|---|
| ||||
Posted in reply to Walter Bright | 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 | ||||
---|---|---|---|---|
| ||||
Posted in reply to bearophile | 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 | ||||
---|---|---|---|---|
| ||||
Posted in reply to Walter Bright | 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 | ||||
---|---|---|---|---|
| ||||
Posted in reply to Walter Bright | 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 | ||||
---|---|---|---|---|
| ||||
Posted in reply to bearophile | 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 | ||||
---|---|---|---|---|
| ||||
Posted in reply to Jason House | 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 | ||||
---|---|---|---|---|
| ||||
Posted in reply to Walter Bright | 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 | ||||
---|---|---|---|---|
| ||||
Posted in reply to Benji Smith | 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. |
Copyright © 1999-2021 by the D Language Foundation