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