cse 3302 - rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfin functional languages...
TRANSCRIPT
![Page 1: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/1.jpg)
CSE 3302Lecture 7: Polymorphism and generics
16 September 2010
Nate NystromUTA
![Page 2: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/2.jpg)
Polymorphism
“poly” = many“morph” = shape
Allow a variable to contain values with different types
2
![Page 3: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/3.jpg)
• OO languages support subtype polymorphism
• A variable can contain an instance of a subtype of the declared type
Subtype polymorphism
3
Number x;
x = new Integer(17);
x = new Float(2.718);
![Page 4: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/4.jpg)
• Allow code to be parametrized on types
• Introduce type variables or type parameters
• Different languages allow one to parametrize classes, interfaces, methods, functions, expressions
Parametric polymorphism
4
class Pair<A,B> { A fst; B snd; }
![Page 5: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/5.jpg)
In functional languages
• Can parametrize algebraic data types:
datatype 'a list = nil | cons of 'a * 'a list
val xs: int list = cons(1, cons(2, nil))
• More on this later in the course.
![Page 6: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/6.jpg)
Parametric polymorphism in OO
• Many OO languages support parametrized classes, interfaces, and methods
• Called generics
• Issues:• What can be parametrized?• What types can be used to instantiate a type
variable?• Bounded polymorphism• Variance• Implementation
![Page 7: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/7.jpg)
Templates
• C++ supports templates
• Similar to generics, but very different semantics and implementation
• Will discuss later
![Page 8: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/8.jpg)
Types parametrized on types
• Can parametrize classes and interfaces/traits:
• Can parametrize methods:
8
class Pair<A,B> { A fst; B snd; }
<A> boolean equal(Pair<A,A> p) {
return p.fst == p.snd;
}
![Page 9: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/9.jpg)
Instantiation
• Type parameters are instantiated on other types.
• As if substitution was performed:
• Consider:class Pair<A,B> { A fst; B snd; }
• Pair<String,Integer> is as if had written
PairSI with the class declaration:class PairSI { String fst; Integer snd; }
![Page 10: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/10.jpg)
Instantiation
• What types can a parameter be instantiated upon?
• Java:
• Any reference type (<: java.lang.Object)
• Scala:• Any type
• C#:• Any type
![Page 11: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/11.jpg)
Bounded polymorphism
• Type parameters can be bounded when declared
• Subtype bounds:• Java:
• Scala:
• Structural bounds:• PolyJ:
11
interface Comparable<T extends Comparable<T>> {...}
def max[A <: Ordered[A]](a: A, b: A) =
if (a < b) b else a
class SortedList[T]
where T { int compareTo(T) } {...}
![Page 12: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/12.jpg)
Variance
• What is the relationship between List[Integer] and List[Number]?
• Should List[Integer] be a subtype of List[Number]?
• For C[X]:
• X is a covariant parameter of C
if C[A] <: C[B] when A <: B
• X is a contravariant parameter of C
if C[A] <: C[B] when B <: A
![Page 13: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/13.jpg)
Covariant parameters
Suppose List[Integer] <: List[Number]
ints: List[Integer] = new List[Integer]();
ints.add(new Integer(23));
nums: List[Number] = ints;
x: Number = ints.get(0);
What about nums.add?
13
![Page 14: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/14.jpg)
Covariant parameters
Suppose List[Integer] <: List[Number]
ints: List[Integer] = new List[Integer]();
ints.add(new Integer(23));
nums: List[Number] = ints;
x: Number = ints.get(0);
nums.add(new Float(56.78));
![Page 15: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/15.jpg)
Covariant parameters
• Cannot call methods that take a covariant parameter as an argument.
• A type system that allows this (without a run-time check) is does not enforce type safety.
![Page 16: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/16.jpg)
Covariant parameters
• In Java, why is List<Integer> not a subtype of List<Number>?
• What happens if we substitute Integer and Number for A in List<A>?
16
class List<Number> {
Number get(int i) {...}
void add(Number v) {...}
}
class List<Integer> {
Integer get(int i) {...}
void add(Integer v) {...}
}
![Page 17: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/17.jpg)
Covariant parameters
• Why is List<Integer> not a subtype of List<Number>?
• What happens if we substitute Integer and Number for A in List<A>?
17
class List<Number> {
Number get(int i) {...}
void add(Number v) {...}
}
class List<Integer> {
Integer get(int i) {...}
void add(Integer v) {...}
}
Covariant method parameters
![Page 18: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/18.jpg)
Covariant parameters
• Scala declares variance at the definition:class List[+A] {...}
• A is a covariant parameter of List
• The compiler checks that a covariant parameter does not occur as a method parameter type.
• => List.add(A) is not allowed.
![Page 19: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/19.jpg)
Wildcards
• Java declares variance at the use:class List<A> {...}new List<? extends A>()
• These are called wildcards.
![Page 20: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/20.jpg)
Covariant wildcards
class List<A> {...}
List<? extends Number> aList;List<Integer> iList = ...; aList = fList;List<Float> fList = ...; aList = iList;
• The type of each element of aList is some statically unknown subtype of Number
![Page 21: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/21.jpg)
Covariant wildcards
class List<A> {...}
List<? extends Number> aList;List<Integer> iList = ...; aList = fList;List<Float> fList = ...; aList = iList;
• Compiler knows that the type parameter is some subtype of Number, but doesn’t know which subtype!
![Page 22: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/22.jpg)
Covariant wildcards
class List<A> {...}
List<? extends Number> aList;List<Integer> iList = ...; aList = fList;List<Float> fList = ...; aList = iList;
• Cannot call methods that take an A, e.g., add
![Page 23: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/23.jpg)
Contravariant wildcards
class List<A> {...}
List<? super Float> aList;List<Object> oList = ...; aList = oList;
• The type of each element of aList is some statically unknown supertype of Float
![Page 24: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/24.jpg)
Contravariant wildcards
class List<A> {...}
List<? super Float> aList;List<Object> oList = ...; aList = oList;
• Compiler knows that the type parameter is some supertype of Float, but doesn’t know which one!
![Page 25: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/25.jpg)
Contravariant wildcards
class List<A> {...}
List<? super Float> aList;List<Object> oList = ...; aList = oList;
• Must assume methods that return an A, e.g., get, return Object.
![Page 26: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/26.jpg)
Wildcard usability
Want a list of Birds
Should one declare a variable as:
• List<Bird> ?• List<? extends Bird> ?• List<? super Bird> ?
Hard to know which to do.
26
![Page 27: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/27.jpg)
Wildcard usability
List<Bird> birds• Cannot do:birds = new List<Penguin>();
• Can do:birds = new List<Bird>();birds.add(new Bird());birds.add(new Penguin());Bird b = birds.get(0);
27
![Page 28: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/28.jpg)
Wildcard usability
List<? extends Bird> birds• Can do:birds = new List<Penguin>();Bird b = birds.get(0);
• Cannot do:birds = new List<Object>();birds.add(new Bird());birds.add(new Penguin());
28
![Page 29: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/29.jpg)
Wildcard usability
List<? super Bird> birds• Can do:birds = new List<Object>();birds.add(new Bird());birds.add(new Penguin());Object o = birds.get(0);
• Cannot do:birds = new List<Penguin>();Bird b = birds.get(0);
29
![Page 30: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/30.jpg)
Variance in Scala
• Scala declares variance at the class definition:class Map[-K,+V] {...}
• Contravariant in K
• Can use V in return types
• Covariant in V
• Can use K in argument types
![Page 31: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/31.jpg)
Variance in C#
• C# does not support variant parameters.
• Why?
![Page 32: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/32.jpg)
Variance in C#
• C# does not support variant parameters.
• Why? Simplifies the language.
![Page 33: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/33.jpg)
Implementation
• Two main approaches:
• Polymorphic translation
• Template instantiation
![Page 34: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/34.jpg)
Polymorphic translation
• Translate a parametrized class into a non-parametrized class
• Insert casts as needed
class C<T> {
T x;
}
C<String> c = new C<String>();
c.x = “abc”;
class C {
Object x;
}
C c = new C();
c.x = “abc”;
String s = (String) c.x;
![Page 35: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/35.jpg)
Template instantiation
• Create a new copy of the parametrized class for every instantiation
• Can be done at compile-time or at run-time.
class C<T> {
T x;
}
C<String> c = new C<String>();
c.x = “abc”;
String s = c.x;
class C$S {
String x;
}
C$S c = new C$S();
c.x = “abc”;
String s = c.x;
![Page 36: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/36.jpg)
Comparison• Polymorphic translation
• usually simpler to implement• much less space overhead
• Java does this
• Template instantiation• can generate code specialized to the type argument
• C# does this (at run-time)
• Scala does both:• polymorphic translation for reference types
• template instantiation for primitives
![Page 37: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/37.jpg)
C++ templates
• Do template instantiation on the source code
• With generics, type-checking of parametrized class done before instantiation
• With templates, type-checking does after instantiation
• C++ compiler needs source code of parametrized classes to instantiate them• No separate compilation when templates used.• Instantiation can fail with bizarre errors.
![Page 38: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/38.jpg)
C#
• CLR generics implemented as run-time template instantiation
• Can be done directly by .NET bytecode. No source required.
• C# compiler checks parametrized code so instantiation should never fail.
![Page 39: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/39.jpg)
Type erasure
• Java erases type arguments from the translation
• This was done to support backward compatibility with older Java code:
• Code that uses Vector can still use Vector<T>
![Page 40: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/40.jpg)
Erasure and run-time types
• Since types are erased, cannot be used for run-time type checking
• Cannot do:x instanceof List<Integer>
• Can only do:x instanceof List
![Page 41: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/41.jpg)
Erasure and run-time typesCasts are unchecked.
List<Integer> xs = (List<Integer>) (List) new List<String>();
succeeds!
Integer i = xs.get(0);fails with a ClassCastException
Translated to:Integer i = (Integer) xs.get(0);
![Page 42: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/42.jpg)
Erasure and varianceBecause types are erased, can side-step variance issues:
List<Number> xs = new List<Integer>(); // illegal!
List<Number> ys = (List) new List<Integer>(); // ok!
Unchecked cast to List will always succeed. But not also:
List<Number> ys = (List) new List<String>(); // ok!
42
![Page 43: CSE 3302 - Rangerranger.uta.edu/~nystrom/courses/cse3302-fa10/lec/3302-07.pdfIn functional languages • Can parametrize algebraic data types: datatype 'a list = nil | cons of 'a *](https://reader034.vdocuments.us/reader034/viewer/2022042804/5f5157f1e5f918157102c2b6/html5/thumbnails/43.jpg)
Summary
• Parameterized types let you reuse code at multiple types
• Found in most modern statically typed languages
• Issues:• What can be parametrized?• What types can one instantiate a parameter with?• Variance and bounds• Implementation: polymorphic or templates