Generics in Java and Beyond

Transcription

1 Generics in Java and Beyond Martin Buechi 2001 by Martin Büchi 1

2 Overview Generics Abstraction of generic concepts. C++ templates (STL), parameterized types, ML polymorphic data types and functions, Beta virtual types First usage: CLU 1977 Talk overview Introduction to generic programming Implementation techniques for generics Generics in JDK 1.5 (2003) 2

3 Stack: Generic Pattern & Generics class Stack { if(t.isinstanceof(o)) void push(object o) { Object pop() { public Stack(Class t) {this.t = t; private Class t; // stack of String Stack s = new Stack(); st.push( Hello ); st.push(new Object()); // ok exception unnecessary cast s = (String)st.pop(); run-time exception class Stack<A> { void push(a o) { A pop() { // stack of String Stack<String> s = new Stack<String>(); st.push( Hello ); st.push(new Object()); // compile-time error s = st.pop(); // no cast needed 3

4 Bounded Polymorphism interface Priority { int getpriority(); class A implements Priority { public int getpriority() { class PriorityQueue<E implements Priority> { E queue[]; void insert(e e) { if(e.getpriority() < queue[i].getpriority()) { PriorityQueue<A> p = new PriorityQueue<A>(); p.insert(new A()); 4

5 F-Bounded Polymorphism interface Comparable<I> { boolean lessthan(i o); class A implements Comparable<A> { public boolean lessthan(a o) { class SortedList<E implements Comparable<E>> { E list[]; void insert(e e) { if(e.lessthan(list[i])) { 5

6 Mix-Ins interface LessAndEqual<I> { boolean lessthan(i o); boolean equal(i o); class A implements LessAndEqual { class Relations<C implements LessAndEqual<C>> extends C { boolean lessthanequal(relations<c> a) { return lessthan(a) equal(a); Relations<A> x = new Relations<A>(); Relations<A> y = new Relations<A>(); if(x.lessthanequal(y)) { 6

7 Parameterized Methods public final class Std { public static <T implements Comparable> T min(t a, T b) { if(a.compareto(b) <= 0) return a; else return b; public class Main { public static void main(string[] args) { Integer b1 = new Integer(2); Integer b2 = new Integer(5); Integer bmin = Std.min(b1, b2); Date d1 = new Date(101, 05, 10); Date d2 = new Date(101, 03, 8); Date dmin = Std.min(d1, d2); System.out.println("The minimums are: " + bmin + " and " + dmin); 7

8 Bounds: Name vs Structural Subtyping class PriorityQueue<E implements Priority> { e.getpriority() class A implements Priority { int getpriority() { class B { int getpriority() { //ok PriorityQueue<A> p = new PriorityQueue<A>(); // compile-time error with name equivalence, ok with structural equivalence PriorityQueue<B> p = new PriorityQueue<B>(); class PriorityQueue<E where {int getpriority();> { 8

9 Insufficient Bounds: Duplicates/Overriding Duplicate methods class C<A implements I> { int m(a s) {return 1; int m(string s) {return 2; Instantiation C<String> illegal: two methods m(string). Overriding error class C<A implements I> extends A { int m() {return 1; class X implements I { void m() { Instantiation C<X> illegal: int m() cannot override void m(). Negative type information would be a solution 9

10 Insufficient Bounds: Instance Creation class C<A implements I> { void f() { A a = new A(); Actual parameter must be a concrete class abstract class X implements I { C<X> x = new C<X>() Actual parameter must have an accessible default constructor class Y implements I {Y(int i) {; C<Y> y = new C<Y>() Bound is insufficient Instantiation that satisfies bound visible from interface may be illegal. 10

11 Subtyping Subtyping of parameterized class implies subtyping class Collection<A> { class Set<A> extends Collection<A> { Collection<X> x = new Set<X> Instantion with subtype does not imply subtyping class Collection<A> { class Y extends X { Collection<Y> y = new Collection<Y>; Collection<X> x = y; // compile-time error x.insert(new X()); // would violate soundness Y[] y = new Y[10]; X[] x = y; // legal x[0] = new X(); //ArrayStoreExc. 11

12 Implementation: Textual Substitution Generic declaration treated as textual macro Source code necessary for instantiation Big and fast Every instantiation consumes secondary & primary storage Speed optimization possible at compile time (limited usefulness) Full reflective inquiry support Package-based accessibility too restrictive Instantiation of generic class p.x accessing package-protected class p.y with package-protected class q.z is not possible Runs on current JVM Reflection does not reveal genericity (Generic class, instantiation parameters(s)) C++ templates based on textual substitution 12

13 Implementation: Heterogeneous Translation Generic class compiled into extended class file Compilation of generic class produces generic class file Normal class file generated upon instantiation Rest as textual substitution 13

14 Implementation: Load-Time Instantiation Compilation of generic class into class file with extensions for compiler and loader Class loader creates instantiations Change of class loader required, but not of verifier/interpreter (security) Small in secondary, big at run-time, pretty fast Only one class file in secondary storage, fast to transmit (applets) Run-time memory needed for each instantiation Run-time (loader, JIT, adaptive) speed optimizations possible Full reflection Package-based accessibility too restrictive Generic class p.x accessing package-protected class p.y instantiated with package-protected class q.z is not possible Minimal changes to JVM required 14

15 Implementation: Generic JVM Compilation of generic class into class file with extensions for compiler and JVM JVM loads, verifies, and executes generic class file Change of JVM, including verifier/interpreter (security) Small in secondary, small at run-time, pretty fast Only one class file in secondary storage, fast to transmit (applets) JVM can optimize run-time memory vs. speed Full reflection Big change to JVM required 15

16 Implementation: Homogeneous Translation Compilation of generic class into class file with extensions for compiler only Formal type parameters replaced by bound Loss of type safety at run time (e.g., can push Object on stack of Strings) Small and slow Only one class file in secondary storage, fast to transmit (applets) Only one instance at run time No speed optimizations possible (small problem for reference types) Speed penalty due to casts Limited reflection Runs on current JVM 16

17 Generics in Java Last minute consideration by Gosling and Joy Scrapped due to time pressure, immature proposal, complexity Several proposals to add (ECOOP, OOPSLA) Java Community Process JSR14 Most wanted language feature in Bug Parade Most likely in JDK 1.5 in 2003 Based on GJ Published in OOPSLA 1998 Basis for javac in JDK 1.3 GJ contains generic version of Collection API Binary freely available for download 17

18 GJ: Overview F-bounded polymorphism No mix-ins (parameter as superclass) No change of the virtual machine Homogeneous translation Little support for reflection No instantiation with primitive types No non-type parameters (functors, constants, ) Solves the generic legacy problem 18

19 GJ: Old Code and New Generic Libraries Compilation: replacement of parameter by bound // GJ source class PQ<E implements Priority> { E queue[]; E removefirst() { PQ<A> p = new PQ<A>(); p.insert(new A()); A a = p.removefirst(); Combination with old code // Equivalent byte-code for JVM class PQ { Priority queue[]; Priority removefirst() { PQ p = new PQ(); p.insert(new A()) A a = (A)p.removeFirst(); For JVM, generic code is like code adhering to generic pattern Code compiled for non-generic version of Collection API works with compilation of generic API Compilation of new generic instantiations Class file extension contains bound and parameter 19

20 GJ: Retrofitting Old Code Retrofitting of non-generic binary code // Non-generic class // only binary available // PriorityQueue.class class PriorityQueue { Priority queue[]; Priority removefirst() { // Typing information for retrofitting // No/dummy implementation // PriorityQueue.java class PriorityQueue<E implements Priority> { E queue[]; E removefirst() {return null; gjc PriorityQueue.java -retro PathOfClassFile Adds generic type information from PriorityQueue.java to PriorityQueue.class. Does not change byte code used by JVM, only adds information for correct compilation of instantiations of generic class. Current GJ comes with retrofitted Collection API 20

21 Try It! JDK 1.5 now: GJ C++ templates (STL) Unbounded For the brave: gbeta Generics in form of virtual types. Run-time instantiation of generics 21

22 Read More! Genericity in Java Java Specification Request 14: Bank, Liskov, and Myers. Parameterized Types and Java. POPL 97. Thorup. Genericity in Java with Virtual Types. ECOOP 97. Agesen, Freund, and Mitchell. Adding Type Parameterization to the Java Language. OOPSLA 97. Bracha, Odersky, Stoutamire, and Wadler. Making the future safe for the past: Adding Genericity to the Java Programming Language. OOPSLA 98. Cartwright and Steele. Compatible Genericity with Run-time Types for the Java Programming Language. OOPSLA 98. Type theory Fisher and Mitchell. The Development of Type Systems for Object- Oriented Languages. Theory and Practice of Object Systems, 1(3):

23 Summary & Conclusions Generics are useful Reuse through instantiation of generic concept More compile-time error checking and fewer run-time exceptions Fewer casts: easier to write and faster to execute Implementations Different tradeoffs with respect to secondary and primary memory, speed, safety, reflection accuracy, and need for changes to the JVM. Generics in Java Official support in JDK 1.5, scheduled for 2003 GJ available now, generated code interoperable with normal Java 23