www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Java-like generics in D

reply Frank Benoit <keinfarbton googlemail.com> writes:
As addition to the existing templates, i think java like generics would
be very helpful for D.

The generic could be like this:
1) use the new keyword 'generic' instead of 'template'
2) Typeparameter can only be object or interface types
3) the compiled code does not know the exact type of the instantiation
parameter. (type erasure)
4) the compiler 'inserts' missing casts for the given instantiation type
parameters

Advantages:
5) "lightweight templates", because of no more object code duplication
for new instantiations.
6) the compiler can generate the object code independantly of the
intantiation code
7) no more errors like 'forward reference' for generic, because the
generic can compile without the knowledge of the exact types.

Does that make sense?
Aug 12 2007
next sibling parent reply Henning Hasemann <hhasemann web.de> writes:
Do you mean something like this?
http://www.digitalmars.com/d/phobos/std_boxer.html

Henning

-- 
GPG Public Key:
http://keyserver.ganneff.de:11371/pks/lookup?op=get&search=0xDDD6D36D41911851
Fingerprint: 344F 4072 F038 BB9E B35D  E6AB DDD6 D36D 4191 1851
Aug 12 2007
parent Frank Benoit <keinfarbton googlemail.com> writes:
Henning Hasemann schrieb:
 Do you mean something like this?
 http://www.digitalmars.com/d/phobos/std_boxer.html
 
 Henning
 

no, i meant something like java generics :) http://java.sun.com/j2se/1.5.0/docs/guide/language/generics.html Probably i missed your point. Frank
Aug 12 2007
prev sibling next sibling parent reply Radu <radu.racariu void.space> writes:
Why on earth should some one want to implement such a hack that Java 
generics are?
I think you completely miss understand how templates (generic code) work 
and how bad the Java implementation is. On .Net at least they are more 
than just compiler syntactic sugar. So no, it does not make any sense!

Radu

Frank Benoit wrote:
 As addition to the existing templates, i think java like generics would
 be very helpful for D.

 The generic could be like this:
 1) use the new keyword 'generic' instead of 'template'
 2) Typeparameter can only be object or interface types
 3) the compiled code does not know the exact type of the instantiation
 parameter. (type erasure)
 4) the compiler 'inserts' missing casts for the given instantiation type
 parameters

 Advantages:
 5) "lightweight templates", because of no more object code duplication
 for new instantiations.
 6) the compiler can generate the object code independantly of the
 intantiation code
 7) no more errors like 'forward reference' for generic, because the
 generic can compile without the knowledge of the exact types.

 Does that make sense?

   

Aug 12 2007
parent reply Frank Benoit <keinfarbton googlemail.com> writes:
Radu schrieb:
 Why on earth should some one want to implement such a hack that Java
 generics are?
 I think you completely miss understand how templates (generic code) work
 and how bad the Java implementation is. On .Net at least they are more
 than just compiler syntactic sugar. So no, it does not make any sense!

Several times, i tried to use templates in D. And each time, again i meet these problems: - errors about forward reverences - increasing executable size by massive template instantiation with differnt types. So my understanding is: * templates are perfect to parametrize with primitives, where a different type parameter generated different binary code. (optimized code) * templates are used to make compile time features possible. But if you make something like a simple container, they are not so nice. A generic would be more appropriate in this case. In this case i wish i had that java hack available. Thats why i though generics as an addition to templates could be a good thing.
Aug 12 2007
next sibling parent Radu <radu.racariu void.space> writes:
Frank Benoit wrote:
 Radu schrieb:
   
 Why on earth should some one want to implement such a hack that Java
 generics are?
 I think you completely miss understand how templates (generic code) work
 and how bad the Java implementation is. On .Net at least they are more
 than just compiler syntactic sugar. So no, it does not make any sense!
     

Several times, i tried to use templates in D. And each time, again i meet these problems: - errors about forward reverences - increasing executable size by massive template instantiation with differnt types.

but rather fix the bug. I have to see a case where size bloat really does matter.
 So my understanding is:
 * templates are perfect to parametrize with primitives, where a
 different type parameter generated different binary code. (optimized code)
 * templates are used to make compile time features possible.

   

generic code that performs well and also write smart generic code as D templates are Turing complete.
 But if you make something like a simple container, they are not so nice.
  A generic would be more appropriate in this case. In this case i wish i
 had that java hack available. Thats why i though generics as an addition
 to templates could be a good thing.
   

void* or Object and I think even the casting can be done using D templates and meta programming functions. Java generics are implemented as a hack in the compiler and spec as the JVM doesn't really know anything about the type your container is using, everything is just Object with some casts, this comes from lack of support on the bytecode level and the need to keep backwards compatibility. This is why generics have so little usage across the language as you're limited by lack of expressiveness and power offered otherwise by true generic code.
Aug 12 2007
prev sibling parent reply BCS <ao pathlink.com> writes:
Reply to Frank,

 But if you make something like a simple container, they are not so
 nice.
 A generic would be more appropriate in this case. In this case i wish
 i
 had that java hack available. Thats why i though generics as an
 addition
 to templates could be a good thing.
 

I think I have wanted something along this line: I would like to be able to have template that end up as identical be just aliases to each other. for instance, with the template: |template Type(T) |{ | T Read(Stream s) | { | T ret; | s.ReadExact(&ret, T.sizeof); | return ret; | } |} Type!(dchar).Read and Type!(int).Read are exactly the same code (read and return 32bits) the same can be said for templates that work on classes; when two types are used that derive from the same base and the base has all of the methods that the template uses, then the codes is exactly the same. It would be nice to have some way to tell a template what parts of a type to specialize on (size, how to call a given set of methods, etc.) and then only when these are different will new code be generated) This would work vary well with something like a generic container for objects; while instances of the container take and return a given type (as the programer sees it), in fact the code is the same for all cases and it only deals with general objects.
Aug 12 2007
parent Radu <radu.racariu void.space> writes:
BCS wrote:
 Reply to Frank,

 But if you make something like a simple container, they are not so
 nice.
 A generic would be more appropriate in this case. In this case i wish
 i
 had that java hack available. Thats why i though generics as an
 addition
 to templates could be a good thing.

I think I have wanted something along this line: I would like to be able to have template that end up as identical be just aliases to each other. for instance, with the template: |template Type(T) |{ | T Read(Stream s) | { | T ret; | s.ReadExact(&ret, T.sizeof); | return ret; | } |} Type!(dchar).Read and Type!(int).Read are exactly the same code (read and return 32bits) the same can be said for templates that work on classes; when two types are used that derive from the same base and the base has all of the methods that the template uses, then the codes is exactly the same.

class across the binary JIT image, this could be done in D at the linker level as an optimization pass. Could be an interesting feature.
 It would be nice to have some way to tell a template what parts of a 
 type to specialize on (size, how to call a given set of methods, etc.) 
 and then only when these are different will new code be generated)

 This would work vary well with something like a generic container for 
 objects; while instances of the container take and return a given type 
 (as the programer sees it), in fact the code is the same for all cases 
 and it only deals with general objects.

Aug 12 2007
prev sibling next sibling parent reply Robert Fraser <fraserofthenight gmail.coim> writes:
Frank Benoit Wrote:

 As addition to the existing templates, i think java like generics would
 be very helpful for D.

I think that's an interesting, but wholly unnecessary idea. Generics were added to Java because first-class templates were an impossibility given the bytecode structure. They're a workaround, not a feature to be emulated in other languages.
 Advantages:
 5) "lightweight templates", because of no more object code duplication
 for new instantiations.

Is object code duplication a huge problem? Are you running into all sorts of code bloat in your projects? D programs _do_ tend to wax a little on the large side, but code bloat is hardly the primary factor of this.
 6) the compiler can generate the object code independantly of the
 intantiation code

How is this different from #5?
 7) no more errors like 'forward reference' for generic, because the
 generic can compile without the knowledge of the exact types.
 

there's the one major advantage you've cited, but I don't thin we need a language feature as a workaround for a bug.
 Does that make sense?
 

I get the feeling they would be generally unused and woefully underpowered compared to templates. Look at the uses for generics in Java: almost exclusively in collections and wrapper classes. I've written maybe two generic classes I can think of, their extensibility to user code is limited. D's templates can do _so_ much more.
Aug 12 2007
parent Bill Baxter <dnewsgroup billbaxter.com> writes:
Robert Fraser wrote:
 Frank Benoit Wrote:
 
 As addition to the existing templates, i think java like generics
 would be very helpful for D.
 

I think that's an interesting, but wholly unnecessary idea. Generics were added to Java because first-class templates were an impossibility given the bytecode structure. They're a workaround, not a feature to be emulated in other languages.
 Advantages: 5) "lightweight templates", because of no more object
 code duplication for new instantiations.

Is object code duplication a huge problem? Are you running into all sorts of code bloat in your projects? D programs _do_ tend to wax a little on the large side, but code bloat is hardly the primary factor of this.

 I get the feeling they would be generally unused and woefully
 underpowered compared to templates. Look at the uses for generics in
 Java: almost exclusively in collections and wrapper classes. 

I think that's the point. If all you're writing is a collection class then maybe you don't really need the full power / bloat of D templates. In C++ there's some sort of trick they use to avoid template bloat in which a specialization for void* is used to implement the template for all pointer types. Then the only thing that actually gets instantiated multiple times is some lightweight interface code that does casting to and from UserType to void*. I think that's essentially what generics do for you under the hood. The same approach should work in D, I would think. --bb
Aug 12 2007
prev sibling next sibling parent Regan Heath <regan netmail.co.nz> writes:
Frank Benoit wrote:
 As addition to the existing templates, i think java like generics would
 be very helpful for D.
 
 The generic could be like this:
 1) use the new keyword 'generic' instead of 'template'
 2) Typeparameter can only be object or interface types
 3) the compiled code does not know the exact type of the instantiation
 parameter. (type erasure)
 4) the compiler 'inserts' missing casts for the given instantiation type
 parameters
 
 Advantages:
 5) "lightweight templates", because of no more object code duplication
 for new instantiations.
 6) the compiler can generate the object code independantly of the
 intantiation code
 7) no more errors like 'forward reference' for generic, because the
 generic can compile without the knowledge of the exact types.
 
 Does that make sense?

I wonder if the proposed D macro feature might help implement this sort of thing... Regan
Aug 12 2007
prev sibling parent Reiner Pope <some address.com> writes:
Frank Benoit wrote:
 As addition to the existing templates, i think java like generics would
 be very helpful for D.
 
 The generic could be like this:
 1) use the new keyword 'generic' instead of 'template'
 2) Typeparameter can only be object or interface types
 3) the compiled code does not know the exact type of the instantiation
 parameter. (type erasure)
 4) the compiler 'inserts' missing casts for the given instantiation type
 parameters
 
 Advantages:
 5) "lightweight templates", because of no more object code duplication
 for new instantiations.
 6) the compiler can generate the object code independantly of the
 intantiation code
 7) no more errors like 'forward reference' for generic, because the
 generic can compile without the knowledge of the exact types.
 
 Does that make sense?
 

It certainly makes sense. There's also the point (or is this what you mean by #6?) that don't need to distribute your source code for your generic type. But this is a job for current D: in fact, I had been hoping for compile-time reflection in order to allow this, and I have started writing an implementation. The basic idea is that there's a wrapper template, with prototype as follows: template GenericOf(alias Impl, Args...) The aim is for the GenericOf template to make one (actually, currently it makes two -- one for the actual implementation, and one with distinctive types so that the template parameters can be recognised) instantiation of Impl, and expose a template which wraps this instantiation, providing conversions to and from the base types, so that no conversions have to be done at the call site. I don't know exactly how the C++ version of this -- using a void* instantiation -- works, but I plan to make something more expressive. The Args... tuple specifies for each argument what requirements are placed on the types (this currently just means the base type, and wrapping for structurally-conforming types if desired), mimicking template parameter specialisations, and allowing functions specific on that type to be called (not possible if you just use a void* instantiation). In addition, it is neat because you still write your collection as a template, and just expose the generic with a line like alias GenericOf!(MyCollection, ParameterRequirements) MyGenericCollection; -- Reiner
Aug 13 2007