PARAMETRIC POLYMORPHISM

Transcription

1 PARAMETRIC POLYMORPHISM Java C#! Parametric polymorphism: " Java Generics and Generic C# for.net! The idea: the compiler is able to check parametric classes just looking at their definilon 1

2 Java Generics " Java s genericity mechanism, available since Java 5.0 " Common use: o Use (and implement) generic type- safe containers ArrayList<String> safebox = new ArrayList<String>(); Compile- Eme type- checking is enforced " More sophisecated uses: o Custom generic classes and methods o Bounded genericity (also called constrained genericity) Generic classes 2

3 Generic Classes Before Java Generics 3

4 Diamond An inside view " Generic classes are translated into ordinary classes by the compiler: o This phase is usually called type erasure o The generic type is replaced by Object o Casts are added as needed, aqer checking that they are type- safe " LimitaEons of type erasure: o Can t instaneate generic parameter with primieve types but can use wrapper classes o At runeme you cannot tell the difference between ArrayList<Integer> and ArrayList<String> o o o o ExcepEon classes cannot be generic classes Can t create objects of the generic type but can assign the value null to a variable of generic type Arrays with elements of a generic type parameter cannot be created A staec member cannot reference a generic type parameter 4

5 Generics and Inheritance " Let S be a subtype of T (i.e. S T). There is no inheritance relaeon between: SomeGenericClass<S> SomeGenericClass<T> " The former is not a subtype of the la[er " Howvere: assume AClass to be a non- generic type: " T<AClass> is a subtype of T o T denotes the raw type derived from the generic class T " S<AClass> is a subtype of T<AClass> Generics and Inheritance 5

6 wildcards Unbounded wildcards: Collection<?> Collection of unkwnown(s) It is a super-type of Collection<T>, for any class T A method can read elements from a wildcard collection argument Can assign elements of the collection to references of type Object Cannot add new elements to the collection but it can add new null entries because null is a subtype of every other type Bounded wildcards Collection<? extends X> It is a super-type of Collection<T>, for any subclass T of X A method can read elements from the wildcard collection argument Can assign elements of the collection to references of type X Cannot add new elements to the collection But it can add new null entries because null is a subtype of every other type 6

7 Bounded wildcards Bounded wildcards with lower bound: Collection<? super X> It is a super-type of Collection<T>, for any superclass T of X A method can add elements to the collection (i.e., through the wildcard collection argument) Cannot assign elements of the collection to references of type X But it can read elements and assign them to reference of type Object because Object is a supertype of every other type 7

8 8

9 Checking class definieon! To be able to type- check a parametric class just looking at its definieon we introduce the noeon of bound! As in method arguments have a type, type arguments are bound to other types! The compiler will allow to use values of such types as if upcasted to the bound! Example: class Vector<T : Sortable>! Elements of the vector should implement (or inherit from) Sortable 9

10 Java Generics strategy! JG is an extension of Java! The compiler verifies that generic types are used correctly! Type parameters are dropped and the bound is used instead; downcasts are inserted in the right places! The output is a normal class file unaware of parametric polymorphism Example 10

11 Expressivity vs. efficiency Generics and Java System JG/Pizza Bracha, Odersky, Feature Stoutamire, Wadler Parameterized types! + bounds NextGen Cartwright, Steele! + bounds PolyJ Bank, Liskov, Myers! + constraints Agesen, Freund, Mitchell! + bounds Generic CLR Kennedy, Syme! + bounds Polymorphic methods!! " "! Type checking at point of definition!!! "! Non-reference instantiations " "!!! Exact run-time types "!?!! Polymorphic virtual methods "! " "! Type parameter variance "! " " " 11

12 Issues with Java Generics List<Integer> integers = new ArrayList<Integer>(); Iterable<Integer> iterable = integers; Iterable<Number> numbers = integers; // Damn! The last line won t compile.!!!!!! We create a list of Integers The list can be (up- )casted into an Iterable of Integers. Lists are/behave like Iterables. But the list cannot be casted into an Iterable of Number, even though Integers are/behave like Numbers. The compiler error message isn t parecularly helpful here: Type mismatch: cannot convert from List<Integer> to Iterable<Number> Issues with Java Generics The problem: Java compiler is unable to see the relaeonship between the types Integer and Number when given as generic parameter. Possible SoluEon List<Integer> integers = new ArrayList<Integer>(); List<Number> numberlist = new ArrayList<Number>(); numberlist.addall(integers); Iterable<Number> numbers = numberlist; We split the creaeon and filling of the second List into two steps to make clearer what s happening. By explicitely creaeng a new colleceon and (up- )caseng every element of the List alone, we can show the compiler that everything s ok. 12

13 Generic C# Strategy: GCLR Generic C# compiler! GC# compiler implements a JG like notalon for parametric types! Bounds are the same as in JG! NO type- inference on generic methods: the type must be specified in the call! The compiler relies on GCLR to generate the code! Exact runlme types are granted by CLR so virtual generic methods are allowed! All type constructors can be parameterized: struct, classes, interfaces and delegates. 13

14 Example.field private!0[] v.method private hidebysig specialname rtspecialname instance void.ctor() cil managed {.maxstack 2 ldarg.0 call instance void [mscorlib]system.object::.c tor() ldarg.0 ldc.i4.s 15 newarr!0 stfld!0[] class n.foo<! 0>::v ret } // end of method Foo::.ctor Performance! The idea of extending CLR with generic types seems good; but how about performance?! Although the instanlalon is performed at load Lme the overhead is minimal! Moreover code sharing reduces instanlalons, improving execulon speed! A technique based on diclonaries is employed to keep track of previous instanlated types 14

15 Expressive power of Generics Reminder: subsetuevity 15

16 Generics and Subtyping! Does the rules for sub- types and assignment works for generics? If B <: A, then G<B> <: G<A>? Counter example List<String> ls = new List<String>(); List<Object> lo = ls; // Since String <: Object, so far so good. lo.add(new Object()); String s = ls.get(0); // Error! The rule B <: A G<B> <: G<A> defies the principle of substitution! Other example Given B <: A, and assuming G<B> <: G<A>, then: G<A> ga = gb; would be legal. Actually, type is erased. 16

17 Bounded Wildcard A wildcard does not allow doing much To provide operaeons with wildcard types, one can specify bounds: Upper Bound The ancestor of unknown: G<? extends X> Lower Bound The descendant of unknown: G<? super Y> Bounded Wildcards Subtyping Rules 17

18 Bounded Wildcards - Example G<B> <: G<? extends A> hence legal G<A> <: G<? super B> hence legal Generics and Polymorphism 18

19 Bounded Polymorphism Bounded Wildcard! There is a problem when using wildcards: public void addcircle(collection<? extends Shape> shapes) { } shapes.add(new Circle());! What will happen? Why? 19

20 To wildcard or not to wildcard?! That is the queseon: interface Collection<E> { public boolean containsall(collection<?> c); public boolean addall(collection<? extends E> c); } interface Collection<E> { public <T> boolean containsall(collection<t> c); public <T extends E> boolean addall(collection<t> c); } Lower Bound Example interface sink<t> { flush(t t); } public <T> T flushall(colleceon<t> col, Sink<T> sink) { T last; for (T t: col) { last = t; sink.flush(t); } return last; } 20

21 Lower Bound Example (2) Sink<Object> s; Collection<String> cs; String str = flushall(cs, s); // Error! Lower Bound Example (3) 21

22 Lower Bound Example (4) Given class C<T 1,...,T n > extends B we have C<t 1,...,t n > <: B[t 1 /T 1,..., t n /T n ] 22

23 ManipulaEng types! Grouping values into types has helped us to build be\er compilers! Could we do the same with types?! Types can be grouped by means of inheritance which represents the union of type sets! Parametric types combined with inheritance allow expressing func8on on types: class Stack<T:object> : Container Function name Function arguments Result type Example: generic containers 23