View mode: basic / threaded / horizontal-split · Log in · Help
November 26, 2005
'auto' and type inference
Just taking one of my occasional drive-by peeks to see where D is up to and came
across the following tidbit linked from the changelog. From
http://www.digitalmars.com/d/declaration.html :

"An implicit type inference for a class reference is not an auto declaration,
even if the auto storage class is used:"

Huh? Documented or no, this appears to violate the Principle Of Least
Astonishment with a wire brush, and looks like a straightforward bug to the
casual observer. Can anyone remember the rationale for this?

cheers
Mike
November 26, 2005
Re: 'auto' and type inference
Mike Capp wrote:
> Just taking one of my occasional drive-by peeks to see where D is up to and came
> across the following tidbit linked from the changelog. From
> http://www.digitalmars.com/d/declaration.html :
> 
> "An implicit type inference for a class reference is not an auto declaration,
> even if the auto storage class is used:"
> 
> Huh? Documented or no, this appears to violate the Principle Of Least
> Astonishment with a wire brush, and looks like a straightforward bug to the
> casual observer. Can anyone remember the rationale for this?
> 
> cheers
> Mike
> 
> 

Have you seen the new context of "auto" recently added to the language? 
 It's completely about making the compiler do type inference and has a 
very different meaning/application from the original.  The old meaning 
of "auto" as "automatically destruct at end of scope" doesn't apply in 
those situations.

The above is actually difficult and confusing to read if you are still 
thinking of auto its the original form (such as might be the case if you 
just popped in to see how things are going after being away for awhile). 
 It's just saying that "new context" auto will never have a "old 
context" auto meaning if declared in the style shown in the first 
example (auto c = new C();)  If you declare it like (auto C d = new 
C();), then the "old context" auto applies.

Confusing? Yes, but I think the old context is going to be deprecated 
sometime.  Not sure, though.

-JJR
December 02, 2005
Re: 'auto' and type inference
/* how about... */
{
   auto auto c = new C();
}
/* is c.~this() called? */

Garett
December 02, 2005
Re: 'auto' and type inference
Well, knowing is half the battle.  The difference between auto Foo foo and 
auto foo could be hard to spot.  An 'implicit' keyword would do the trick 
nicely, and prevent the auto/auto confusion.

-------------------------

private import std.stdio;

class Foo {
   char[] s;
   this(char[] s) {
       // Runtime Error: std.format
       //writefln("%s.this();", s);
       writef(s); writefln(".this();");
       this.s = s;
   }
   ~this() {
       // Runtime Error: std.format
       //writefln("%s.~this();", s);
       writef(s); writefln(".~this();");
   }
}

int main(char[][] args) {

   {
       auto Foo foo = new Foo("auto Foo foo");
   }

   writefln("auto Foo foo should have destructed by now.\n");

   {
       // compiler error: redundant storage class 'auto'
       //auto auto foo = new Foo("auto auto foo");
   }

   {
       auto foo = new Foo("auto foo");
   }

   writefln("auto foo has not destructed yet.");

   return 0;
}

/*
   auto Foo foo.this();
   auto Foo foo.~this();
   auto Foo foo should have destructed by now.

   auto foo.this();
   auto foo has not destructed yet.
   auto foo.~this();
*/


"Garett Bass" <garettbass@studiotekne.com> wrote in message 
news:dmpdno$10uj$1@digitaldaemon.com...
> /* how about... */
> {
>    auto auto c = new C();
> }
> /* is c.~this() called? */
>
> Garett
>
Top | Discussion index | About this forum | D home