www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Alternative typeof syntax

reply bearophile <bearophileHUGS lycos.com> writes:
What do you think about the the syntax  x.typeof  instead of  typeof(x)  ?
There are situations where you will need to parenthesize anyway, for example:

import std.stdio;
void main() {
    int x = 1;
    float y = 1.5;
    writeln(typeid(typeof(x + y)));
}

You have to write:
(x + y).typeof

But in many situations you don't need the (). 
And it gets more similar/uniform to the x.sizeof syntax too (that is sizeof(x)
in C).

Bye,
bearophile
May 17 2010
next sibling parent reply "Nick Sabalausky" <a a.a> writes:
"bearophile" <bearophileHUGS lycos.com> wrote in message 
news:hss6b6$aep$1 digitalmars.com...

 What do you think about the the syntax  x.typeof  instead of  typeof(x)  ?
 There are situations where you will need to parenthesize anyway, for 
 example:

 import std.stdio;
 void main() {
    int x = 1;
    float y = 1.5;
    writeln(typeid(typeof(x + y)));
 }

 You have to write:
 (x + y).typeof

 But in many situations you don't need the ().
 And it gets more similar/uniform to the x.sizeof syntax too (that is 
 sizeof(x) in C).


vote++

Anything that reduces parenthesis-hell without inviting ambiguities in 
either the compiler or the "human-eye parser" is good by me :)

Besides, I love member access syntax in general. In addition to (safely) 
reducing parenthesis, it also sidesteps the oddity that nested function 
calls are written/read *backwards* from the order of execution (ie, 
"A(B(C()))" means "call C, then B, then A"). I've even been toying with the 
idea of a language design that places primary emphasis on member-call syntax 
and consistent left-to-right ordering.
May 17 2010
parent reply Clemens <eriatarka84 gmail.com> writes:
Nick Sabalausky Wrote:


 Besides, I love member access syntax in general. In addition to (safely) 
 reducing parenthesis, it also sidesteps the oddity that nested function 
 calls are written/read *backwards* from the order of execution (ie, 
 "A(B(C()))" means "call C, then B, then A"). I've even been toying with the 
 idea of a language design that places primary emphasis on member-call syntax 
 and consistent left-to-right ordering.


You mean like Smalltalk?
May 18 2010
next sibling parent "Nick Sabalausky" <a a.a> writes:
"Clemens" <eriatarka84 gmail.com> wrote in message 
news:hstgm2$2pr6$1 digitalmars.com...

 Nick Sabalausky Wrote:


 Besides, I love member access syntax in general. In addition to (safely)
 reducing parenthesis, it also sidesteps the oddity that nested function
 calls are written/read *backwards* from the order of execution (ie,
 "A(B(C()))" means "call C, then B, then A"). I've even been toying with 
 the
 idea of a language design that places primary emphasis on member-call 
 syntax
 and consistent left-to-right ordering.


 You mean like Smalltalk?


Not really sure. All I remember from when I looked into Smalltalk was that 
even the most basic logic constructs were forced into being objects/classes, 
which make their use needlessly awkward.
May 18 2010
prev sibling parent reply Ary Borenszweig <ary esperanto.org.ar> writes:
Clemens wrote:

 Nick Sabalausky Wrote:
 

 Besides, I love member access syntax in general. In addition to (safely) 
 reducing parenthesis, it also sidesteps the oddity that nested function 
 calls are written/read *backwards* from the order of execution (ie, 
 "A(B(C()))" means "call C, then B, then A"). I've even been toying with the 
 idea of a language design that places primary emphasis on member-call syntax 
 and consistent left-to-right ordering.


 
 You mean like Smalltalk?


You mean like Ruby? :-)
May 18 2010
parent Clemens <eriatarka84 gmail.com> writes:
Ary Borenszweig Wrote:


 Clemens wrote:

 Nick Sabalausky Wrote:
 

 Besides, I love member access syntax in general. In addition to (safely) 
 reducing parenthesis, it also sidesteps the oddity that nested function 
 calls are written/read *backwards* from the order of execution (ie, 
 "A(B(C()))" means "call C, then B, then A"). I've even been toying with the 
 idea of a language design that places primary emphasis on member-call syntax 
 and consistent left-to-right ordering.


 
 You mean like Smalltalk?


 
 You mean like Ruby? :-)


Heh, yes ;)

Of course Smalltalk was there first, prior art and all that. I had some fun
with it again over the weekend... it's a really neat language, a shame that it
never really caught on in a big way. Perhaps the whole image-based development
thing was just too different from how everyone was/is working.

By the way, another interesting (though less widely known) language that also
builds upon that legacy is Io: http://www.iolanguage.com/
May 19 2010
prev sibling parent bearophile <bearophileHUGS lycos.com> writes:
I have added it as request:
http://d.puremagic.com/issues/show_bug.cgi?id=4272
Jun 04 2010