• coxalan <coxalan web.de> Sep 21 2007
• Robert Fraser <fraserofthenight gmail.com> Sep 21 2007
• BCS <BCS pathlink.com> Sep 21 2007
• Daniel Keep <daniel.keep.lists gmail.com> Sep 21 2007
• Bruno Medeiros <brunodomedeiros+spam com.gmail> Sep 21 2007

coxalan <coxalan web.de> writes:

Hello!

There are situations where you want an exact clone of a class, including two
separated sets of static class members.

A first try using typedef:

import std.stdio;

class foo {
    static uint a;
}

typedef foo foo1;
typedef foo foo2;

void main() {
    foo1.a = 1;
    foo2.a = 2;
    writefln(foo1.a);
    writefln(foo2.a);
}

gives the output
2
2

So typedef gives new types foo1 and foo2, but they share the same static class
members.


A version which distinguishes the two copies by a template id:

import std.stdio;

class foo(uint id) {
    static uint a;
}


void main() {
    foo!(1).a = 1;
    foo!(2).a = 2;
    writefln(foo!(1).a);
    writefln(foo!(2).a);
}

gives the output
1
2


So basically this works.
But the problem is, that the code of the class needs to be extended by a id
template variable.


I wonder if it would make sense to introduce a new keyword, say 'clone', which
works like 'typedef', but additionally gives a new set of static class members.

coxalan

Robert Fraser <fraserofthenight gmail.com> writes:

coxalan Wrote:

 Hello!
 
 There are situations where you want an exact clone of a class, including two
separated sets of static class members.
 
 A first try using typedef:
 
 import std.stdio;
 
 class foo {
     static uint a;
 }
 
 typedef foo foo1;
 typedef foo foo2;
 
 void main() {
     foo1.a = 1;
     foo2.a = 2;
     writefln(foo1.a);
     writefln(foo2.a);
 }
 
 gives the output
 2
 2
 
 So typedef gives new types foo1 and foo2, but they share the same static class
members.
 


I've _never_ run into this situation, and I doubt it's a common one. Certainly
too limited, IMO, for a language feature.
 
 A version which distinguishes the two copies by a template id:
 
 import std.stdio;
 
 class foo(uint id) {
     static uint a;
 }
 
 
 void main() {
     foo!(1).a = 1;
     foo!(2).a = 2;
     writefln(foo!(1).a);
     writefln(foo!(2).a);
 }
 
 gives the output
 1
 2
 
 
 So basically this works.
 But the problem is, that the code of the class needs to be extended by a id
template variable.
 
 
 I wonder if it would make sense to introduce a new keyword, say 'clone', which
works like 'typedef', but additionally gives a new set of static class members.
 
 coxalan

BCS <BCS pathlink.com> writes:

Robert Fraser wrote:
 
 I've _never_ run into this situation, and I doubt it's a common one. Certainly
too limited, IMO, for a language feature.
 


I run into it all the time when I want to create a new Exception type.

I practically have "class NewExp:Exception{this(char[]c){super(c);}}" 
burned into my keyboard

Daniel Keep <daniel.keep.lists gmail.com> writes:

BCS wrote:
 Robert Fraser wrote:
 I've _never_ run into this situation, and I doubt it's a common one.
 Certainly too limited, IMO, for a language feature.


 I run into it all the time when I want to create a new Exception type.
 
 I practically have "class NewExp:Exception{this(char[]c){super(c);}}"
 burned into my keyboard


I feel your pain.

import util.ex;
// adds trailing Exception for me b/c I'm declared lazy ;)
mixin NewException!("DivideByCucumber");

	-- Daniel

Bruno Medeiros <brunodomedeiros+spam com.gmail> writes:

coxalan wrote:
 Hello!
 
 There are situations where you want an exact clone of a class, including two
separated sets of static class members.
 
 A first try using typedef:
 
 import std.stdio;
 
 class foo {
     static uint a;
 }
 
 typedef foo foo1;
 typedef foo foo2;
 
 void main() {
     foo1.a = 1;
     foo2.a = 2;
     writefln(foo1.a);
     writefln(foo2.a);
 }
 
 gives the output
 2
 2
 
 So typedef gives new types foo1 and foo2, but they share the same static class
members.
 
 
 A version which distinguishes the two copies by a template id:
 
 import std.stdio;
 
 class foo(uint id) {
     static uint a;
 }
 
 
 void main() {
     foo!(1).a = 1;
     foo!(2).a = 2;
     writefln(foo!(1).a);
     writefln(foo!(2).a);
 }
 
 gives the output
 1
 2
 
 
 So basically this works.
 But the problem is, that the code of the class needs to be extended by a id
template variable.
 
 
 I wonder if it would make sense to introduce a new keyword, say 'clone', which
works like 'typedef', but additionally gives a new set of static class members.
 
 coxalan


One alternative is to put the class's body into a template and then use 
template mixins to create several "clones":

template Foo_body() {
   static uint a;
   int b;
   void someMethod() {}
}

class Foo1 { mixin Foo_body!(); }

class Foo2 { mixin Foo_body!(); }

-- 
Bruno Medeiros - MSc in CS/E student
http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D