www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Templates and the '!'

reply Sha Chancellor <schancel pacific.net> writes:
I just was looking at a piece of code.  And while this is largely my 
problem, I keep reading:

Foo!(int)

as 
Foo not int.

And thinking what on earth? And then remembering oh yeah templates...

Why are we using the ! symbol for templates?  Couldn't we use a | or 
something else?  # isn't used, neither is   or $.
Jul 23 2004
next sibling parent reply Berin Loritsch <bloritsch d-haven.org> writes:
Sha Chancellor wrote:

 I just was looking at a piece of code.  And while this is largely my 
 problem, I keep reading:
 
 Foo!(int)
 
 as 
 Foo not int.
 
 And thinking what on earth? And then remembering oh yeah templates...
 
 Why are we using the ! symbol for templates?  Couldn't we use a | or 
 something else?  # isn't used, neither is   or $.

I agree. Foo!(int) Foo|(int) Foo:(int) Foo (int) Foo#(int) Foo$(int) Out of the options listed, I think I like the pipe or colon declarator the best. The "!" symbol just naturally maps to "not" in many people's minds.
Jul 23 2004
next sibling parent Daniel Horn <hellcatv hotmail.com> writes:
you've corrupted me!(Human)
now i'll see func!(type) as a not...
never saw it before you said it, and I've been a C++ programmer for ages

Berin Loritsch wrote:
 Sha Chancellor wrote:
 
 I just was looking at a piece of code.  And while this is largely my 
 problem, I keep reading:

 Foo!(int)

 as Foo not int.

 And thinking what on earth? And then remembering oh yeah templates...

 Why are we using the ! symbol for templates?  Couldn't we use a | or 
 something else?  # isn't used, neither is   or $.

I agree. Foo!(int) Foo|(int) Foo:(int) Foo (int) Foo#(int) Foo$(int) Out of the options listed, I think I like the pipe or colon declarator the best. The "!" symbol just naturally maps to "not" in many people's minds.

Jul 23 2004
prev sibling next sibling parent reply Arcane Jill <Arcane_member pathlink.com> writes:
In article <cdrvjf$2md5$1 digitaldaemon.com>, Berin Loritsch says...
I agree.

Foo!(int)
Foo|(int)
Foo:(int)
Foo (int)
Foo#(int)
Foo$(int)

Out of the options listed, I think I like the pipe or colon declarator
the best.

Well, would I be shot down in flames for suggesting this, rather obvious, alternative: Foo<int> Arcane Jill
Jul 23 2004
next sibling parent reply Sean Kelly <sean f4.ca> writes:
In article <cds3re$2qcl$1 digitaldaemon.com>, Arcane Jill says...
In article <cdrvjf$2md5$1 digitaldaemon.com>, Berin Loritsch says...
I agree.

Foo!(int)
Foo|(int)
Foo:(int)
Foo (int)
Foo#(int)
Foo$(int)

Out of the options listed, I think I like the pipe or colon declarator
the best.

Well, would I be shot down in flames for suggesting this, rather obvious, alternative: Foo<int>

hehe... As for the previous suggestions, the colon is used as a label specifier while pipe is not easily accessible on many international keyboards. From a purely semantic standpoint, "!" correlates much more closely with something like template instantiation than with negation. But then we're all victims of convention ;) I like it how it is. The only other one I sort of like from a visual standpoint is "$" Sean
Jul 23 2004
parent reply Andrew Edwards <ridimz_at yahoo.dot.com> writes:
Sean Kelly wrote:
 In article <cds3re$2qcl$1 digitaldaemon.com>, Arcane Jill says...
 
In article <cdrvjf$2md5$1 digitaldaemon.com>, Berin Loritsch says...

I agree.

Foo!(int)
Foo|(int)
Foo:(int)
Foo (int)
Foo#(int)
Foo$(int)

Out of the options listed, I think I like the pipe or colon declarator
the best.

Well, would I be shot down in flames for suggesting this, rather obvious, alternative: Foo<int>

hehe... As for the previous suggestions, the colon is used as a label specifier while pipe is not easily accessible on many international keyboards. From a purely semantic standpoint, "!" correlates much more closely with something like template instantiation than with negation. But then we're all victims of convention ;) I like it how it is. The only other one I sort of like from a visual standpoint is "$" Sean

I have to agree with Sean here. ! seems completely natural to me. Then again, I'm a Neophyte "D" Programmer: naturally biased towards all things "D".
Jul 23 2004
parent reply Sha Chancellor <schancel pacific.net> writes:
In article <cds80e$2u3d$1 digitaldaemon.com>, Andrew Edwards says...
Sean Kelly wrote:
 In article <cds3re$2qcl$1 digitaldaemon.com>, Arcane Jill says...
 
In article <cdrvjf$2md5$1 digitaldaemon.com>, Berin Loritsch says...

I agree.

Foo!(int)
Foo|(int)
Foo:(int)
Foo (int)
Foo#(int)
Foo$(int)

Out of the options listed, I think I like the pipe or colon declarator
the best.

Well, would I be shot down in flames for suggesting this, rather obvious, alternative: Foo<int>

hehe... As for the previous suggestions, the colon is used as a label specifier while pipe is not easily accessible on many international keyboards. From a purely semantic standpoint, "!" correlates much more closely with something like template instantiation than with negation. But then we're all victims of convention ;) I like it how it is. The only other one I sort of like from a visual standpoint is "$" Sean

I have to agree with Sean here. ! seems completely natural to me. Then again, I'm a Neophyte "D" Programmer: naturally biased towards all things "D".

I think I like the $ as the best alternative also. :P Foo$(int) looks good to me.
Jul 23 2004
parent reply "Walter" <newshound digitalmars.com> writes:
"Sha Chancellor" <schancel pacific.net> wrote in message
news:cds920$2us1$1 digitaldaemon.com...
 I think I like the $ as the best alternative also. :P

 Foo$(int) looks good to me.

Yeah, but you'd run afoul of all those folks who want to use $ as a synonym for array.length <g>.
Jul 25 2004
parent reply Stewart Gordon <smjg_1998 yahoo.com> writes:
Walter wrote:

 "Sha Chancellor" <schancel pacific.net> wrote in message
 news:cds920$2us1$1 digitaldaemon.com...
 
I think I like the $ as the best alternative also. :P

Foo$(int) looks good to me.

Yeah, but you'd run afoul of all those folks who want to use $ as a synonym for array.length <g>.

Maybe we should show some international awareness.... Foo£(int) :-) Stewart. -- My e-mail is valid but not my primary mailbox, aside from its being the unfortunate victim of intensive mail-bombing at the moment. Please keep replies on the 'group where everyone may benefit.
Jul 26 2004
next sibling parent "C. Sauls" <ibisbasenji yahoo.com> writes:
Stewart Gordon wrote:
 Maybe we should show some international awareness....
     Foo£(int)

While we're at it, let me propose FooŚ¶ā(int) -Chris S. -Invironz
Jul 26 2004
prev sibling parent reply Arcane Jill <Arcane_member pathlink.com> writes:
In article <ce2naq$oi2$3 digitaldaemon.com>, Stewart Gordon says...

Maybe we should show some international awareness....

     Foo£(int)

:-)

Stewart.

I realise you were joking. (I noticed the smiley!). But in general we should all be aware that this sort of thing is not possible. From the D manual: D source text can be in one of the following formats: * ASCII * UTF-8 * UTF-16BE * UTF-16LE * UTF-32BE * UTF-32LE You'd have to cross ASCII off that list if we were to allow non-ASCII characters in required syntax. Jill
Jul 26 2004
parent Stewart Gordon <smjg_1998 yahoo.com> writes:
Arcane Jill wrote:

 In article <ce2naq$oi2$3 digitaldaemon.com>, Stewart Gordon says...
 
 Maybe we should show some international awareness....

     Foo£(int)

 :-)


 You'd have to cross ASCII off that list if we were to allow non-ASCII
characters
 in required syntax.

I realise you realise I was joking. (I noticed the acknowledgement of the smiley!) But a module isn't required to instantiate templates for it to be a valid D module. Stewart. -- My e-mail is valid but not my primary mailbox, aside from its being the unfortunate victim of intensive mail-bombing at the moment. Please keep replies on the 'group where everyone may benefit.
Jul 26 2004
prev sibling next sibling parent reply J C Calvarese <jcc7 cox.net> writes:
Arcane Jill wrote:
 In article <cdrvjf$2md5$1 digitaldaemon.com>, Berin Loritsch says...
 
I agree.

Foo!(int)
Foo|(int)
Foo:(int)
Foo (int)
Foo#(int)
Foo$(int)

Out of the options listed, I think I like the pipe or colon declarator
the best.

Well, would I be shot down in flames for suggesting this, rather obvious, alternative: Foo<int> Arcane Jill

No flames. But there's a good reason why D didn't go down this road. Using < and > for templates invites all kinds of parsing headaches (something about how < and > are already operators). It's Walter's compiler and he wanted to design it so that parsing is easy and fun. By the way, don't you miss the instance keyword? instance Foo(int) iFoo; Ah, the good old days... -- Justin (a/k/a jcc7) http://jcc_7.tripod.com/d/
Jul 23 2004
parent reply Arcane Jill <Arcane_member pathlink.com> writes:
In article <cdsb9n$30ne$1 digitaldaemon.com>, J C Calvarese says...

 Foo<int>


But there's a good reason why D didn't go down this road. 
Using < and > for templates invites all kinds of parsing headaches 
(something about how < and > are already operators). It's Walter's 
compiler and he wanted to design it so that parsing is easy and fun.

Hmmm. Then I think Walter should stop writing <g> in his emails. Jill !(g)
Jul 26 2004
parent reply Berin Loritsch <bloritsch d-haven.org> writes:
Arcane Jill wrote:

 In article <cdsb9n$30ne$1 digitaldaemon.com>, J C Calvarese says...
 
 
Foo<int>


But there's a good reason why D didn't go down this road. 
Using < and > for templates invites all kinds of parsing headaches 
(something about how < and > are already operators). It's Walter's 
compiler and he wanted to design it so that parsing is easy and fun.

Hmmm. Then I think Walter should stop writing <g> in his emails. Jill !(g)

Great one! ROTFLOL
Jul 26 2004
next sibling parent h3r3tic <h3r3tic dev.null> writes:
Berin Loritsch wrote:
 Arcane Jill wrote:
 
 In article <cdsb9n$30ne$1 digitaldaemon.com>, J C Calvarese says...


 Foo<int>


 But there's a good reason why D didn't go down this road. Using < and 
 for templates invites all kinds of parsing headaches (something 

he wanted to design it so that parsing is easy and fun.

Hmmm. Then I think Walter should stop writing <g> in his emails. Jill !(g)

Great one! ROTFLOL

Or just at least use <g /> to be compatible with XHTML and not spreading that old HTML bullshit
Jul 26 2004
prev sibling parent reply John Reimer <brk_6502 yahoo.com> writes:
On Mon, 26 Jul 2004 11:24:33 -0400, Berin Loritsch wrote:

 Hmmm. Then I think Walter should stop writing <g> in his emails.
 
 Jill  !(g)

Great one! ROTFLOL

That actually was pretty funny... :-) Does that mean the 'g' stands for "generic," then?
Jul 27 2004
parent reply Berin Loritsch <bloritsch d-haven.org> writes:
John Reimer wrote:

 On Mon, 26 Jul 2004 11:24:33 -0400, Berin Loritsch wrote:
 
 
Hmmm. Then I think Walter should stop writing <g> in his emails.

Jill  !(g)

Great one! ROTFLOL

That actually was pretty funny... :-) Does that mean the 'g' stands for "generic," then?

In netspeak it is supposed to be a synonym for "grin", or basically don't take the comment too seriously.
Jul 27 2004
parent John Reimer <brk_6502 yahoo.com> writes:
On Tue, 27 Jul 2004 17:18:31 -0400, Berin Loritsch wrote:

 
 Does that mean the 'g' stands for "generic," then?

In netspeak it is supposed to be a synonym for "grin", or basically don't take the comment too seriously.

Yes, I realize that. That was just my weak attempt at extending the joke. :-(
Jul 27 2004
prev sibling parent reply Elephant <Elephant_member pathlink.com> writes:
In article <cds3re$2qcl$1 digitaldaemon.com>, Arcane Jill says...
In article <cdrvjf$2md5$1 digitaldaemon.com>, Berin Loritsch says...
I agree.

Foo!(int)
Foo|(int)
Foo:(int)
Foo (int)
Foo#(int)
Foo$(int)

Out of the options listed, I think I like the pipe or colon declarator
the best.

Well, would I be shot down in flames for suggesting this, rather obvious, alternative: Foo<int> Arcane Jill

Well, would I be shot down in flames for suggesting this, rather obvious,
alternative:

Booo!!! Booooooooooo!!!
Foo!(int)
Foo|(int)
Foo:(int)
Foo (int)
Foo#(int)
Foo$(int)


Pipe is logical OR no ? , colon is label specifier, the others are ugly, i personally like the !. $ <- scalar <- array # <- comment! Purple Elephant
Jul 23 2004
parent Sha Chancellor <schancel pacific.net> writes:


personally like the !. $ <- scalar <- array # <- comment! Purple Elephant

This isn't perl-land. # is not a comment, and $ is not a scalar. and is just for email addresses. :P
Jul 23 2004
prev sibling parent reply "Walter" <newshound digitalmars.com> writes:
"Berin Loritsch" <bloritsch d-haven.org> wrote in message
news:cdrvjf$2md5$1 digitaldaemon.com...
 Foo|(int)
 Foo:(int)

These have parsing ambiguity problems.
 Foo (int)
 Foo#(int)
 Foo$(int)

I try to avoid using characters not in the C set.
 The "!" symbol just naturally maps to "not" in many people's minds.

"*" piped to multiply in my mind before I started using C <g>.
Jul 25 2004
parent reply h3r3tic <h3r3tic_member pathlink.com> writes:
I try to avoid using characters not in the C set.

Sorry, but what's the reason ? D is a new language, it's not meant to be compatible with C or C++. Why then restrict to that 30 year old standard ? OT: If I were making up the syntax, I'd make it use Python-like indentation instead of curly braces but that's just the broken CPU in my head ;)
Jul 25 2004
next sibling parent reply Mike Parker <aldacron71 yahoo.com> writes:
h3r3tic wrote:

 Sorry, but what's the reason ? D is a new language, it's not meant to be
 compatible with C or C++. Why then restrict to that 30 year old standard ?

Ah, but it is meant to be compatible with C at the binary level and, to a lesser extent, at the syntax level. The less you deviate from traditional C syntax the easier it is to learn the language.
Jul 26 2004
next sibling parent h3r3tic <h3r3tic dev.null> writes:
Mike Parker wrote:
 h3r3tic wrote:
 
 Sorry, but what's the reason ? D is a new language, it's not meant to be
 compatible with C or C++. Why then restrict to that 30 year old 
 standard ?

Ah, but it is meant to be compatible with C at the binary level and, to a lesser extent, at the syntax level. The less you deviate from traditional C syntax the easier it is to learn the language.

Yet I dont think that foo!(int) is a small deviation from the C syntax. It will seem to C programmers as foo not int. Making it foo (int) for instance (heh, instance...) would make them think "aaaahh, that's something different!" and reading foo at int, pretty much seems logical as a template specialization. AT reads as SPECIALIZED BY in my mind. But again, I don't think I can make anyone/Walter change the current syntax. Yet I still think that if someone is smart enough to learn C, they would be smart enough to learn some syntax changes. Anyway, I hope we'll have implicit specializations so I don't have to use foo!(int) too often
Jul 26 2004
prev sibling parent Berin Loritsch <bloritsch d-haven.org> writes:
Mike Parker wrote:

 h3r3tic wrote:
 
 Sorry, but what's the reason ? D is a new language, it's not meant to be
 compatible with C or C++. Why then restrict to that 30 year old 
 standard ?

Ah, but it is meant to be compatible with C at the binary level and, to a lesser extent, at the syntax level. The less you deviate from traditional C syntax the easier it is to learn the language.

Yes, but the D templating feature is a complete deviation from C/C++/Java/C# templates (they all use the angle bracket notation <>) already. So either use that notation, or if it makes sense, finish the job and use a character not in use in the C language already. WOT: Someone I know and respect (having been in the computing industry for a long time) seriously believes that the creators of C (and Unix) did it as a practical joke. "Why not make things as obtuse as possible?" In the process of making it obtuse, it was also very powerful, and caught on like wildfire (better than using COBOL or assembly for cross platform work). I don't have anything to support his claims, but it is just crazy enough to have some truth to it :)
Jul 26 2004
prev sibling parent Matthias Becker <Matthias_member pathlink.com> writes:
OT: If I were making up the syntax, I'd make it use Python-like indentation
instead of curly braces but that's just the broken CPU in my head ;)

int main () cout << "Hello, World\n" way cooler then int main () { cout << "Hello, World\n" }
Jul 26 2004
prev sibling next sibling parent reply "Jarrett Billingsley" <kb3ctd2 yahoo.com> writes:
is there any reason it can't be just

Foo(int) a;

?

perhaps it has something to do with it looking a lot like a function.

personally i think Foo!(int) looks like Foo *factorial* int.  i was confused
as hell when i updated D from 0.74 to 0.94 (i forgot about D for a while)
when i saw all these List!(int) and what have you.
Jul 23 2004
parent David Medlock <amedlock nospam.org> writes:
Jarrett Billingsley wrote:
 is there any reason it can't be just
 
 Foo(int) a;
 
 ?
 
 perhaps it has something to do with it looking a lot like a function.
 
 personally i think Foo!(int) looks like Foo *factorial* int.  i was confused
 as hell when i updated D from 0.74 to 0.94 (i forgot about D for a while)
 when i saw all these List!(int) and what have you.
 
 

Maybe the ! is an upside down i for instance? Hehe. The colon looks natural but also looks like a label. The string is unused so it would get my vote as an alternative. Hmmmm arguing syntax and not semantics....flamewar approaching! HEHEHE
Jul 23 2004
prev sibling next sibling parent "C. Sauls" <ibisbasenji yahoo.com> writes:
Sha Chancellor wrote:
 Why are we using the ! symbol for templates?  Couldn't we use a | or 
 something else?  # isn't used, neither is   or $.

Actually, # is used for Special Token Sequences: http://www.digitalmars.com/d/lex.html#specialtokens I'm happy with ! but if it were changed, I'd vote for $ above all. -Chris S. -Invironz
Jul 23 2004
prev sibling next sibling parent Derek <derek psyc.ward> writes:
On Fri, 23 Jul 2004 14:03:21 -0700, Sha Chancellor wrote:

 I just was looking at a piece of code.  And while this is largely my 
 problem, I keep reading:
 
 Foo!(int)
 
 as 
 Foo not int.
 
 And thinking what on earth? And then remembering oh yeah templates...
 
 Why are we using the ! symbol for templates?  Couldn't we use a | or 
 something else?  # isn't used, neither is   or $.

Okay, I'll bite too! I still have a mental hiccup when seeing all those '!' symbols embedded inside template instances. Foo(int) is my preference. The ' ' signifying that the next token 'Foo' is a template name and the template is now being instantiated, using 'int' as its argument. However, I haven't been able to grok the whole D template system. Every thime I read the docs and examples, I come away even more confused. I've tried a few times to play with them but it still does not make any sense to me. I guess I'm not sure what problems are trying to be solved by them. But I haven't given up yet. ;-) -- Derek Melbourne, Australia
Jul 23 2004
prev sibling next sibling parent Charles Hixson <charleshixsn earthlink.net> writes:
Sha Chancellor wrote:
 I just was looking at a piece of code.  And while this is largely my 
 problem, I keep reading:
 
 Foo!(int)
 
 as 
 Foo not int.
 
 And thinking what on earth? And then remembering oh yeah templates...
 
 Why are we using the ! symbol for templates?  Couldn't we use a | or 
 something else?  # isn't used, neither is   or $.

OK. Well, how about: Foo!!(int) Or even (sorry Walter) Foo!int! I suppose I'm getting too Eiffelish here, and Walter doesn't like separated markers. So I propose The operator should be !! It's name should be _instance_ (just in case we ever want to allow it to be overridden). Spaces before and after it should be optional. So, probably, should be the parens. A type argument is required.
Jul 25 2004
prev sibling parent Matthias Becker <Matthias_member pathlink.com> writes:
Why are we using the ! symbol for templates?  Couldn't we use a | or 
something else?  # isn't used, neither is   or $.

Jul 26 2004