NOTE: this bug has been closed as a duplicate of 4064105.  If you
wish to vote for this issue in JDC, please vote for 4064105 instead.





*Description:

We know that JavaSoft have a working implementation of templatized
classes for Java. It uses the pervasive dynamic type information
in Java to avoid many of the problems associated with templates
in C++. This would be a very useful feature because it would make
code that used collections much easier to write. Quite a few people
in  xxxxx  are very interested in this feature, and would like to see
it finished in time for JDK1.3.
======================================================================

N/A

   I believe that a clean, simple parameterized typing facility (along the
lines of http://www.cs.bell-labs.com/who/wadler/pizza/gj/index.html )
would represent a fine addition to the language, especially when combined with
the 1.2 collections facility.

  xxxxx@xxxxx   1998-09-16


Parameterization can indeed be very useful.  In considering the various
proposals, we are particularly concerned about the impact of such a
large change on our customers, especially with respect to compatibility
and stability.

The investigation of our options is ongoing.

  xxxxx@xxxxx   1998-09-16

GJ rocks, and I'd love to see this be an official
part of Java.

Perhaps it's too late for Java 1.2, but I believe
this one feature adds tremendous value to the
language with minimal threat and no real loss of
consistency or simplicity.  Perhaps 1.2.1?

Even though it would dificult to retrofit the current Java platform to use
parametrized types, they should be made available ...
I do not recommend changing current API's ...
No attempt should be made to force:
Vector<String> to be a subclass of Vector<Object>
or Vector<Object> to be the same as Vector ...
This would be too much to handle, many developers
would waste alot of time recoding their routines ...
JDK 1.2 collections could be changed ...Uh Oh too late

Adding parameterized types would enhance both the
compile time safety of the language and would
speed coding.  Java is sorely in need of this.

This is my single most-desired feature for Java.  It makes
code easier to write, easier to statically check, and
easier to read.  Once you start to sling around Hashtables
of Strings to Hashtables, you really, really want
to be able to specify it as:
Hashtable<String,Hashtable<String,String>>
rather than hoping that it will all just work out.
And the GJ approach (via erasure, to ensure compatability 
with old code/libraries), seems to be a win all
around.

The flip side of this would be unboxing in
type-constrained containers which would be
a big win for primitive types 
(ie. no more wrappers), and other specialisations
on the basis of type.

In reality, I haven't tried to generate the bug.
I like gj and found it useful. I would like to
see it (or a form of template) in the next Java jdk.
Thanks!

definitely missing, but maybe the VisualJ++ guys 
are faster