www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Anonymous classes should pass through super ctors

reply Frank Benoit <keinfarbton googlemail.com> writes:
Anonymous classes should pass through super ctors, if no ctor is given.

class C {
    this( int i ){ .... }
    abstract void run();
    // ...
}

auto c = new class(3) C {
    this( int a ){ super(a); } //<-- this line should not be necessary.
    void run(){}
};
Aug 15 2008
next sibling parent reply "Jarrett Billingsley" <kb3ctd2 yahoo.com> writes:
"Frank Benoit" <keinfarbton googlemail.com> wrote in message 
news:g83v3k$n2u$1 digitalmars.com...
 Anonymous classes should pass through super ctors, if no ctor is given.

 class C {
    this( int i ){ .... }
    abstract void run();
    // ...
 }

 auto c = new class(3) C {
    this( int a ){ super(a); } //<-- this line should not be necessary.
    void run(){}
 };

All classes should pass through super ctors. :|
Aug 15 2008
next sibling parent BCS <ao pathlink.com> writes:
Reply to Jarrett,

 "Frank Benoit" <keinfarbton googlemail.com> wrote in message
 news:g83v3k$n2u$1 digitalmars.com...
 
 Anonymous classes should pass through super ctors, if no ctor is
 given.
 
 class C {
 this( int i ){ .... }
 abstract void run();
 // ...
 }
 auto c = new class(3) C {
 this( int a ){ super(a); } //<-- this line should not be necessary.
 void run(){}
 };


There needs to be a way to block that. That said, the current block-by-default is annoying.
Aug 15 2008
prev sibling next sibling parent reply Bruno Medeiros <brunodomedeiros+spam com.gmail> writes:
Jarrett Billingsley wrote:
 "Frank Benoit" <keinfarbton googlemail.com> wrote in message 
 news:g83v3k$n2u$1 digitalmars.com...
 Anonymous classes should pass through super ctors, if no ctor is given.

 class C {
    this( int i ){ .... }
    abstract void run();
    // ...
 }

 auto c = new class(3) C {
    this( int a ){ super(a); } //<-- this line should not be necessary.
    void run(){}
 };

All classes should pass through super ctors. :|

Yes, if this was to be fixed/changed, it should be for all classes, not just anonymous ones. I remember this issue (the automatic inheritance of ctors) being discussed before. What were the opinions of the community? And Walters? (I don't recall myself) If there was something approaching consensus, it might be worth opening a bug ticket. -- Bruno Medeiros - Software Developer, MSc. in CS/E graduate http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D
Aug 18 2008
next sibling parent reply Frank Benoit <keinfarbton googlemail.com> writes:
Bruno Medeiros schrieb:
 Jarrett Billingsley wrote:
 "Frank Benoit" <keinfarbton googlemail.com> wrote in message 
 news:g83v3k$n2u$1 digitalmars.com...
 Anonymous classes should pass through super ctors, if no ctor is given.

 class C {
    this( int i ){ .... }
    abstract void run();
    // ...
 }

 auto c = new class(3) C {
    this( int a ){ super(a); } //<-- this line should not be necessary.
    void run(){}
 };

All classes should pass through super ctors. :|

Yes, if this was to be fixed/changed, it should be for all classes, not just anonymous ones. I remember this issue (the automatic inheritance of ctors) being discussed before. What were the opinions of the community? And Walters? (I don't recall myself) If there was something approaching consensus, it might be worth opening a bug ticket.

Aren't anonymous classes a special case? Because they are only instantiated once with exactly those arguments given in the declaration.
Aug 18 2008
parent reply "Steven Schveighoffer" <schveiguy yahoo.com> writes:
"Frank Benoit" wrote
 Bruno Medeiros schrieb:
 Jarrett Billingsley wrote:
 "Frank Benoit" <keinfarbton googlemail.com> wrote in message 
 news:g83v3k$n2u$1 digitalmars.com...
 Anonymous classes should pass through super ctors, if no ctor is given.

 class C {
    this( int i ){ .... }
    abstract void run();
    // ...
 }

 auto c = new class(3) C {
    this( int a ){ super(a); } //<-- this line should not be necessary.
    void run(){}
 };

All classes should pass through super ctors. :|

Yes, if this was to be fixed/changed, it should be for all classes, not just anonymous ones. I remember this issue (the automatic inheritance of ctors) being discussed before. What were the opinions of the community? And Walters? (I don't recall myself) If there was something approaching consensus, it might be worth opening a bug ticket.

Aren't anonymous classes a special case? Because they are only instantiated once with exactly those arguments given in the declaration.

Yeah, but if you're going to have auto-inheritance of constructors, why not make it so I don't have to do this: class Base { this(int arg1, int arg2, char[] arg3, int arg4, float arg5) { ... } } class Derived : Base { this(int arg1, int arg2, char[] arg3, int arg4, float arg5) { super(arg1, arg2, arg3, arg4, arg5); } } This can get annoying for a large hierarchy where you always want to inherit the base class' intiailization methods. If we're going to get a way to do it for anonymous classes, I'd like it to be universal and consistent. -Steve
Aug 18 2008
next sibling parent reply Frank Benoit <keinfarbton googlemail.com> writes:
Steven Schveighoffer schrieb:
 "Frank Benoit" wrote
 Bruno Medeiros schrieb:
 Jarrett Billingsley wrote:
 "Frank Benoit" <keinfarbton googlemail.com> wrote in message 
 news:g83v3k$n2u$1 digitalmars.com...
 Anonymous classes should pass through super ctors, if no ctor is given.

 class C {
    this( int i ){ .... }
    abstract void run();
    // ...
 }

 auto c = new class(3) C {
    this( int a ){ super(a); } //<-- this line should not be necessary.
    void run(){}
 };


just anonymous ones. I remember this issue (the automatic inheritance of ctors) being discussed before. What were the opinions of the community? And Walters? (I don't recall myself) If there was something approaching consensus, it might be worth opening a bug ticket.

Because they are only instantiated once with exactly those arguments given in the declaration.

Yeah, but if you're going to have auto-inheritance of constructors, why not make it so I don't have to do this: class Base { this(int arg1, int arg2, char[] arg3, int arg4, float arg5) { ... } } class Derived : Base { this(int arg1, int arg2, char[] arg3, int arg4, float arg5) { super(arg1, arg2, arg3, arg4, arg5); } } This can get annoying for a large hierarchy where you always want to inherit the base class' intiailization methods. If we're going to get a way to do it for anonymous classes, I'd like it to be universal and consistent. -Steve

I feel, that this is dangerous. If there are such complicated ctors, they should be forwarded explicitly. But i have no real argument :) In case of anonymous classes, the syntax should be compact. I think there are good reasons why Java does handle it this way.
Aug 18 2008
parent reply Bruno Medeiros <brunodomedeiros+spam com.gmail> writes:
Frank Benoit wrote:
 Steven Schveighoffer schrieb:
 "Frank Benoit" wrote
 Bruno Medeiros schrieb:
 Jarrett Billingsley wrote:
 "Frank Benoit" <keinfarbton googlemail.com> wrote in message 
 news:g83v3k$n2u$1 digitalmars.com...
 Anonymous classes should pass through super ctors, if no ctor is 
 given.

 class C {
    this( int i ){ .... }
    abstract void run();
    // ...
 }

 auto c = new class(3) C {
    this( int a ){ super(a); } //<-- this line should not be 
 necessary.
    void run(){}
 };


not just anonymous ones. I remember this issue (the automatic inheritance of ctors) being discussed before. What were the opinions of the community? And Walters? (I don't recall myself) If there was something approaching consensus, it might be worth opening a bug ticket.

Because they are only instantiated once with exactly those arguments given in the declaration.

Yeah, but if you're going to have auto-inheritance of constructors, why not make it so I don't have to do this: class Base { this(int arg1, int arg2, char[] arg3, int arg4, float arg5) { ... } } class Derived : Base { this(int arg1, int arg2, char[] arg3, int arg4, float arg5) { super(arg1, arg2, arg3, arg4, arg5); } } This can get annoying for a large hierarchy where you always want to inherit the base class' intiailization methods. If we're going to get a way to do it for anonymous classes, I'd like it to be universal and consistent. -Steve

I feel, that this is dangerous. If there are such complicated ctors, they should be forwarded explicitly. But i have no real argument :)

I don't see how this could be dangerous in any way whatsoever, if the ctor inheritance rules followed the same rules as method inheritance rules: * if you don't override or overload any ctor in the overload set, then the whole overload set is available in the child class. * if you do override or overload any ctor, well... follow the same rules as overriding/overloading a method. -- Bruno Medeiros - Software Developer, MSc. in CS/E graduate http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D
Aug 18 2008
parent reply BCS <ao pathlink.com> writes:
Reply to Bruno,

 I don't see how this could be dangerous in any way whatsoever, if the
 ctor inheritance rules followed the same rules as method inheritance
 rules:
 * if you don't override or overload any ctor in the overload set, then
 the whole overload set is available in the child class.
 * if you do override or overload any ctor, well... follow the same
 rules
 as overriding/overloading a method.

There needs to be an easy way to forbid one, several or all base constructors. And while were at it, it would be nice to add an auto constructor that is added to all constrictors (kind of like member variable initialization in c#)
Aug 18 2008
parent reply "Steven Schveighoffer" <schveiguy yahoo.com> writes:
"BCS" wrote
 Reply to Bruno,

 I don't see how this could be dangerous in any way whatsoever, if the
 ctor inheritance rules followed the same rules as method inheritance
 rules:
 * if you don't override or overload any ctor in the overload set, then
 the whole overload set is available in the child class.
 * if you do override or overload any ctor, well... follow the same
 rules
 as overriding/overloading a method.

There needs to be an easy way to forbid one, several or all base constructors.

If you want to forbid all constructors, make a private constructor in the derived class. Due to the scope resolution rules of D, only the most derived class' counts, unless you alias the parent's. If you want to forbid one, then you have to forbid it the same way you do normal methods, implement all the ones you don't want to forbid. Yes, this is a pain, but it is consistent. If Walter wants to add a way to selectively alias in base methods, then use that way, but it needs to be consistent.
 And while were at it, it would be nice to add an auto constructor that is 
 added to all constrictors (kind of like member variable initialization in 
 c#)

It would be nice to be able to do this with runtime constructs, instead of being limited to compile-time ones. -Steve
Aug 18 2008
parent reply BCS <ao pathlink.com> writes:
Reply to Steven,

 "BCS" wrote
 
 Reply to Bruno,
 
 I don't see how this could be dangerous in any way whatsoever, if
 the
 ctor inheritance rules followed the same rules as method inheritance
 rules:
 * if you don't override or overload any ctor in the overload set,
 then
 the whole overload set is available in the child class.
 * if you do override or overload any ctor, well... follow the same
 rules
 as overriding/overloading a method.

constructors.

the derived class. Due to the scope resolution rules of D, only the most derived class' counts, unless you alias the parent's.

yup
 If you want to forbid one, then you have to forbid it the same way you
 do normal methods, implement all the ones you don't want to forbid.
 

one option would be: private this(/* the signiture *){assert(false);} // forbid this alias this this; // get everything else
 And while were at it, it would be nice to add an auto constructor
 that is added to all constrictors (kind of like member variable
 initialization in c#)
 

instead of being limited to compile-time ones.

I'm not following...
 -Steve
 

Aug 18 2008
parent reply "Steven Schveighoffer" <schveiguy yahoo.com> writes:
"BCS" <ao pathlink.com> wrote in message 
news:55391cb330b528cacf3c1a094fc2 news.digitalmars.com...
 Reply to Steven,

 "BCS" wrote

 Reply to Bruno,

 I don't see how this could be dangerous in any way whatsoever, if
 the
 ctor inheritance rules followed the same rules as method inheritance
 rules:
 * if you don't override or overload any ctor in the overload set,
 then
 the whole overload set is available in the child class.
 * if you do override or overload any ctor, well... follow the same
 rules
 as overriding/overloading a method.

constructors.

the derived class. Due to the scope resolution rules of D, only the most derived class' counts, unless you alias the parent's.

yup
 If you want to forbid one, then you have to forbid it the same way you
 do normal methods, implement all the ones you don't want to forbid.

one option would be: private this(/* the signiture *){assert(false);} // forbid this alias this this; // get everything else

Good, I think this would work with the current rules of overloading.
 And while were at it, it would be nice to add an auto constructor
 that is added to all constrictors (kind of like member variable
 initialization in c#)

instead of being limited to compile-time ones.

I'm not following...

i.e. you can already do this today: class X { int blah = 5; } But it has to be a compile-time constant. It would be nice if you could use a runtime evaluated value. -Steve
Aug 18 2008
parent BCS <ao pathlink.com> writes:
Reply to Steven,

 And while were at it, it would be nice to add an auto constructor
 that is added to all constrictors (kind of like member variable
 initialization in c#)
 

instead of being limited to compile-time ones.


class X { int blah = 5; } But it has to be a compile-time constant. It would be nice if you could use a runtime evaluated value. -Steve

Ah, now I'm reading you correctly. That's exactly what I'm asking for. :)
Aug 18 2008
prev sibling parent BCS <ao pathlink.com> writes:
Reply to Steven,

 If we're going to get a way to do it for anonymous classes, I'd like
 it to be universal and consistent.
 
 -Steve
 

// do all alias this this; // do just this one alias this(int, char[]) this;
Aug 18 2008
prev sibling parent Sean Kelly <sean invisibleduck.org> writes:
Bruno Medeiros wrote:
 Jarrett Billingsley wrote:
 "Frank Benoit" <keinfarbton googlemail.com> wrote in message 
 news:g83v3k$n2u$1 digitalmars.com...
 Anonymous classes should pass through super ctors, if no ctor is given.

 class C {
    this( int i ){ .... }
    abstract void run();
    // ...
 }

 auto c = new class(3) C {
    this( int a ){ super(a); } //<-- this line should not be necessary.
    void run(){}
 };

All classes should pass through super ctors. :|


Okay... I decided to dig up the proposal after all: http://www.digitalmars.com/d/archives/digitalmars/D/Inheriting_constructors_54088.html Sean
Aug 18 2008
prev sibling parent "Denis Koroskin" <2korden gmail.com> writes:
On Mon, 18 Aug 2008 23:13:42 +0400, Sean Kelly <sean invisibleduck.org>  
wrote:

 Bruno Medeiros wrote:
 Jarrett Billingsley wrote:
 "Frank Benoit" <keinfarbton googlemail.com> wrote in message  
 news:g83v3k$n2u$1 digitalmars.com...
 Anonymous classes should pass through super ctors, if no ctor is  
 given.

 class C {
    this( int i ){ .... }
    abstract void run();
    // ...
 }

 auto c = new class(3) C {
    this( int a ){ super(a); } //<-- this line should not be necessary.
    void run(){}
 };

All classes should pass through super ctors. :|


Okay... I decided to dig up the proposal after all: http://www.digitalmars.com/d/archives/digitalmars/D/Inheriting_constructors_54088.html Sean

FWIW, C++0x has this feature and we still don't :p http://en.wikipedia.org/wiki/C++0x#Object_construction_improvement
Aug 23 2008
prev sibling parent Sean Kelly <sean invisibleduck.org> writes:
Frank Benoit wrote:
 Anonymous classes should pass through super ctors, if no ctor is given.
 
 class C {
    this( int i ){ .... }
    abstract void run();
    // ...
 }
 
 auto c = new class(3) C {
    this( int a ){ super(a); } //<-- this line should not be necessary.
    void run(){}
 };

I'd argue that ctors should always be inherited if no ctor is defined, much like the regular function lookup rules for classes. In fact, I posted a proposal regarding this maybe a year ago, but I'm too lazy to go looking for it now. Sean
Aug 18 2008