Java ParTy: Parameterized Types in Java

Description of the Problem

Java, as currently defined, lacks support for parameterized types. A programmer that wants to define a group of related types that have similar behavior but manipulate different types cannot always do so in Java. However, the language was designed to be expandable as the need for new programming power arises. We believe that Java users would benefit from the additional power of generic abstractions in code, and in our project, we will propose and implement an extension to Java that adds support for parametric polymorphism.
 
 

There have already been several attempts at offering support for parameterized types in Java (PolyJ, Pizza, GJ, and others). Each of these previous attempts is cleverly designed to offer complete support for all flavors of parametric polymorphism. Accommodating all possible scenarios of generic abstractions is a difficult programming task, and the current extensions handle these problems quite well.
 
 

Instead of trying to provide a better version of the same complete extension, we will take a different approach. Firstly, we will examine what properties of parameterized types are most valuable to Java users. We wish to answer the question: What makes parameterized types valuable to programmers? We believe that determining the usefulness of the extension is of primary importance, and we will then use this knowledge to guide our design, rather than attempting to provide full support first, and then reflect on its usefulness after the implementation is complete.
 
 

After choosing what makes parameterized types valuable to programmers, we will finally design and implement a limited version of these features. We aim to add only the most useful extensions to Java, and will not add complexity to the language unless its usefulness outweighs its complexity.
 
 

Related Work
 
 

A number of researchers have already looked at how to add generic types to Java.

• Myers, Bank, and Liskov's work on PolyJ, published in POPL 97.
• Odersky and Wadler's previous work on Pizza, published in POPL 97.
• Wadler, Odersky, Bracha, and Stoutamire work on GJ.
• Agesen, Freund, and Mitchell's work on supporting generic types in the class loader, published in OOPSLA 97.
• Cartwright and Steele's work on NextGen, a Java extension (and a GJ extension) that passes types at runtime, published in OOPSLA 98.
• Thorup's work on virtual types in Java, published in ECOOP 97.
• Bruce, Odersky, and Wadler's work on statically safe virtual types, published in ECOOP 98.
• Bokowski and DahmĘs work on Poor Man's Genericity, an implementation of parameterized classes (constrained parametric polymorphism) for Java.
• Kiev --- an extension of the Java language with parameterized types, closures, multimethods, multiple inheritance, extended syntax and semantic of loop and switch statements and more.

Milestones:

1. (Feb. 28) Examine what properties of parameterized types are most valuable to Java users. This includes an investigation of current implementations of parameterized types in Java.
2. (Mar. 23) Design a language extension to provide these valuable properties in Java.
3. (Apr. 14) Implement the above design.
4. (Apr. 21) Test and evaluate the above implementation.
5. (Apr. 27) Document our work, and write a report describing our design decisions, our implementation, and how well our decisions held up to evaluation.

Division of labor:

1. Each member of the team researches one or two of the existing implementations of parameterized types.
2. After forming a consensus about our approach, each team member works on one part of the project: one for semantics, one for syntax, one for lexical design, and the other one for error checking.
3. After the above work is completed, two of us test the implementation and the other two do the evaluation.
4. All of us work together to prepare the final report.
 

Evaluation Criteria
 
 

The goal of this project is to allow common parameterized classes to be programmed in Java. In this project, we are most interested in making it easy to handle common, useful cases rather than maximizing absolute language expressiveness. The language extension should be implemented so as try to preserve Java's code executing efficiency without changing Java's robustness.
 
 

Therefore, the criteria for evaluating our project are the following according to the above motivation:

• Design an expressive type parameterized mechanism, which should include syntax and semantics definitions.
• Implement this type extension.
• Write a Java virtual machine extension to support parameterized types.
• Compare this method with other methods in language design and implementation views. Where does our implementation provide useful extensions to the language, and where does it fail to do so? How much extra support does our extension add to the language?
• Finally, we must systematically show that our method of extension is beneficial in ways that other methods are not. We hope that our extensions will be most valuable to users, and we hope to show that the extensions we do not support are also extensions that are not necessary tools for most programmers. We should measure the performance cost of our implementation, and compare it with that of previous ones.