Re: Different types with auto

2011-03-19 Thread Bekenn

On 3/18/2011 12:59 PM, bearophile wrote:

http://d.puremagic.com/issues/show_bug.cgi?id=2656


Thank goodness that's under discussion.


Re: Different types with auto

2011-03-18 Thread Regan Heath
On Fri, 18 Mar 2011 00:30:30 -, Andrei Alexandrescu  
seewebsiteforem...@erdani.org wrote:



On 3/17/11 7:27 PM, KennyTM~ wrote:

On Mar 18, 11 04:17, Jason E. Aten wrote:

auto x1=1., x2=2., x3=3., x4=4., x5=5, x6=6.;


If the coder wanted them to all be doubles, it's easy to require that  
by

just saying so, and then even x5 will be a double.

double x1=1., x2=2, ...

So it seems to me that auto does exactly what you asked it to here,  
and I

actually prefer this behavior for conciseness and expressiveness sake.



auto x1 = templateFunctionWithComplicatedReturnType(a),
x2 = templateFunctionWithComplicatedReturnType(b),
x3 = templateFunctionWithComplicatedReturnType('c'),
x4 = templateFunctionWithComplicatedReturnType(d);


Yah, not sure what would ever be bad about that.


Nor is there anything bad about this:

auto x1 = templateFunctionWithComplicatedReturnType(a);
auto x2 = templateFunctionWithComplicatedReturnType(b);
auto x3 = templateFunctionWithComplicatedReturnType('c');
auto x4 = templateFunctionWithComplicatedReturnType(d);

in fact, it lines up neatly so I prefer it :P

--
Using Opera's revolutionary email client: http://www.opera.com/mail/


Re: Different types with auto

2011-03-18 Thread Jacob Carlborg

On 2011-03-17 21:35, Nick Sabalausky wrote:

bearophilebearophileh...@lycos.com  wrote in message
news:iltdqr$1rd7$1...@digitalmars.com...


D disallows bug-prone C syntax like this (C style guides strongly suggest
to declare only each variable in a distinct statement and line of code):

int a = 1, *b = null;

D accepts code like:


auto a = 1, b = null;


This seems against the D rule of not allowing different types to be
initialized in the same statement. In my opinion on this design detail D
is worse than C++0x. As an example, if you write a line of code like this,
meaning it to initialize six double variables, you have a bug:

auto x1=1., x2=2., x3=3., x4=4., x5=5, x6=6.;



I'm not sure how I feel about D's auto creating multiple types in one
statement. But at the very least, I think your code above is yet another
good example of why 1. and .1 float-literal syntax needs to die, die,
die. It does what? Saves one character just so it can be less readable and
cause syntax problems for new potential features? Bah.


Yes, it must die. It also conflicts with uniform function call syntax.



There are only few (one?) other thing(s) that I think C++0x gets better
than D, like a more strict enum, I don't understand why D doesn't follows
C++0x design on this other detail:
http://d.puremagic.com/issues/show_bug.cgi?id=3999



I agree that would be nice. Weak typing like that is one of the reasons I
abandoned C/C++, but D still holds on to it in this particular case.






--
/Jacob Carlborg


Re: Different types with auto

2011-03-18 Thread bearophile
Jacob Carlborg:

 Yes, it must die. It also conflicts with uniform function call syntax.

Currently this is mixed with the octal literals discussion:
http://d.puremagic.com/issues/show_bug.cgi?id=2656
http://d.puremagic.com/issues/show_bug.cgi?id=3837

But I think it's better to move it to a specific enhancement request about FP 
literals only.

Bye,
bearophile


Different types with auto

2011-03-17 Thread bearophile
I have found this article through Reddit (the Reddit page already contains 
comments by Andrei), C++0x feature support in GCC 4.5 by Arpan Sen:
http://www.ibm.com/developerworks/aix/library/au-gcc/index.html

The article probably doesn't contain new things for people that have closely 
followed the design and development of C++0x, but for less experienced people 
it shows several D features that are now more or less present in C++ too (as 
soon as C++ compilers catch up).

One thing of that page has caught my attention, in Listing 7, about erroneous 
use of the auto keyword:

int main( )
{
   auto i = 9, j = 8.2; // error – i and j should be same type
   auto k = k; // dumb error – can’t declare and use in initializer
   ...
}

According to the article the first line generates the error:
1.cpp:3:8: error: inconsistent deduction for 'auto': 'int' and then 'double'

This is a difference between D auto and C++0x auto, because this is accepoted 
by D:

void main() {
   auto i = 9, j = 8.2;
}


There was a thread about related matters in the d.learn newsgroup, started by 
Ellery Newcomer:
http://www.mail-archive.com/digitalmars-d-learn@puremagic.com/msg09361.html


D disallows bug-prone C syntax like this (C style guides strongly suggest to 
declare only each variable in a distinct statement and line of code):

int a = 1, *b = null;

D accepts code like:

 auto a = 1, b = null;

This seems against the D rule of not allowing different types to be initialized 
in the same statement. In my opinion on this design detail D is worse than 
C++0x. As an example, if you write a line of code like this, meaning it to 
initialize six double variables, you have a bug:

auto x1=1., x2=2., x3=3., x4=4., x5=5, x6=6.;

-

There are only few (one?) other thing(s) that I think C++0x gets better than D, 
like a more strict enum, I don't understand why D doesn't follows C++0x design 
on this other detail:
http://d.puremagic.com/issues/show_bug.cgi?id=3999

Bye,
bearophile


Re: Different types with auto

2011-03-17 Thread Jason E. Aten
 auto x1=1., x2=2., x3=3., x4=4., x5=5, x6=6.;

If the coder wanted them to all be doubles, it's easy to require that by 
just saying so, and then even x5 will be a double.

double x1=1., x2=2, ...

So it seems to me that auto does exactly what you asked it to here, and I 
actually prefer this behavior for conciseness and expressiveness sake.



Re: Different types with auto

2011-03-17 Thread Nick Sabalausky
bearophile bearophileh...@lycos.com wrote in message 
news:iltdqr$1rd7$1...@digitalmars.com...

 D disallows bug-prone C syntax like this (C style guides strongly suggest 
 to declare only each variable in a distinct statement and line of code):

 int a = 1, *b = null;

 D accepts code like:

 auto a = 1, b = null;

 This seems against the D rule of not allowing different types to be 
 initialized in the same statement. In my opinion on this design detail D 
 is worse than C++0x. As an example, if you write a line of code like this, 
 meaning it to initialize six double variables, you have a bug:

 auto x1=1., x2=2., x3=3., x4=4., x5=5, x6=6.;


I'm not sure how I feel about D's auto creating multiple types in one 
statement. But at the very least, I think your code above is yet another 
good example of why 1. and .1 float-literal syntax needs to die, die, 
die. It does what? Saves one character just so it can be less readable and 
cause syntax problems for new potential features? Bah.


 There are only few (one?) other thing(s) that I think C++0x gets better 
 than D, like a more strict enum, I don't understand why D doesn't follows 
 C++0x design on this other detail:
 http://d.puremagic.com/issues/show_bug.cgi?id=3999


I agree that would be nice. Weak typing like that is one of the reasons I 
abandoned C/C++, but D still holds on to it in this particular case.





Re: Different types with auto

2011-03-17 Thread Jonathan M Davis
On Thursday, March 17, 2011 13:17:33 Jason E. Aten wrote:
  auto x1=1., x2=2., x3=3., x4=4., x5=5, x6=6.;
 
 If the coder wanted them to all be doubles, it's easy to require that by
 just saying so, and then even x5 will be a double.
 
 double x1=1., x2=2, ...
 
 So it seems to me that auto does exactly what you asked it to here, and I
 actually prefer this behavior for conciseness and expressiveness sake.

Personally, I hate it when variables are declared no the same line period, and 
I 
find the fact that auto allows you to have multiple variables on the same line 
to 
be inconsistent with other declarations. Just because auto infers the type 
doesn't mean that they variables being declared with it shouldn't all have the 
same type. I was _very_ surprised when I learned that auto allowed you to 
declare different types of variables on the same line, and I think that it's 
definitely bad. But since pretty much the only time that I ever declare 
multiple 
variables on the same line is before the condition of a for loop, it's not like 
it's causing me any grief either way. And if I react negatively to it in code, 
I'm already reacting negatively to someone having declared multiple variables 
on 
the same line anyway.

- Jonathan M Davis


Re: Different types with auto

2011-03-17 Thread KennyTM~

On Mar 18, 11 04:17, Jason E. Aten wrote:

auto x1=1., x2=2., x3=3., x4=4., x5=5, x6=6.;


If the coder wanted them to all be doubles, it's easy to require that by
just saying so, and then even x5 will be a double.

double x1=1., x2=2, ...

So it seems to me that auto does exactly what you asked it to here, and I
actually prefer this behavior for conciseness and expressiveness sake.



auto x1 = templateFunctionWithComplicatedReturnType(a),
 x2 = templateFunctionWithComplicatedReturnType(b),
 x3 = templateFunctionWithComplicatedReturnType('c'),
 x4 = templateFunctionWithComplicatedReturnType(d);


Re: Different types with auto

2011-03-17 Thread Andrei Alexandrescu

On 3/17/11 7:27 PM, KennyTM~ wrote:

On Mar 18, 11 04:17, Jason E. Aten wrote:

auto x1=1., x2=2., x3=3., x4=4., x5=5, x6=6.;


If the coder wanted them to all be doubles, it's easy to require that by
just saying so, and then even x5 will be a double.

double x1=1., x2=2, ...

So it seems to me that auto does exactly what you asked it to here, and I
actually prefer this behavior for conciseness and expressiveness sake.



auto x1 = templateFunctionWithComplicatedReturnType(a),
x2 = templateFunctionWithComplicatedReturnType(b),
x3 = templateFunctionWithComplicatedReturnType('c'),
x4 = templateFunctionWithComplicatedReturnType(d);


Yah, not sure what would ever be bad about that.

Andrei