• Mike Capp (10/10) Nov 26 2005 Just taking one of my occasional drive-by peeks to see where D is up to ...
• John Reimer (16/31) Nov 26 2005 Have you seen the new context of "auto" recently added to the language?
• Garett Bass (6/6) Dec 02 2005 /* how about... */
• Garett Bass (44/51) Dec 02 2005 Well, knowing is half the battle. The difference between auto Foo foo a...

Mike Capp <mike.capp gmail.com> writes:

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

John Reimer <terminal.node gmail.com> writes:

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

"Garett Bass" <garettbass studiotekne.com> writes:

/* how about... */
{
    auto auto c = new C();
}
/* is c.~this() called? */

Garett 

"Garett Bass" <garettbass studiotekne.com> writes:

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