Adobe PDF

Today’s Agenda 

Types 

* Polymorphism 

- Types and Reuse 

- Ad-hoc vs. Universal Polymorphism 

* Parametric Types 

* Subtyping

Types, Abstraction and Reuse 

Use of Types 

Recall: Readability, Classification 

Classification helps in commonizing representation 

and implementation of operation 

Types are abstractions 

Capture specific features of a set of values for 

classification 

Types can also improve reuse (of code) 

4/11/2008 Sundar B., BITS, Pilani. CS C362 2

Types and Reuse 

Consider the following examples: 

NULL pointer in C (or null in Java) 

What is its type? 

A function for computing the length of a linked list 

in C 

What is its type? 

What should be its type? 

A function for computing the area of (closed 

graphic) shapes 

What should be its type? 


Polymorphism - Definition 

poly ( many ) + morph (forms i.e shapes i.e. 

types) 

polymorphism = values taking more than one type 

(recall: values of a type share representation i.e share 

shape) 

Values – may be simple data, functions, or objects. 

2 major kinds 

ad-hoc : not true but apparent polymorphism. 

Syntactic Reuse 

universal: true polymorphism. 

Semantic Reuse 


Polymorphism - Adhoc 

Ad-hoc polymorphism is further divided 

into two kinds: 

Coercion (Implicit/Explicit Type Conversion) 

e.g. Integer values in C conditional statement 

E.g. Type conversion in C assignment statements 

Explicit (programmer specified) type casting 

Overloading 


Polymorphism – Ad hoc 

Overloading 

e.g. In C, 

0 : int; 0:float; 0:char. 

+ : int int ; + : float float 

e.g., In C++/Java: 

void print(int x); 

void print(String s); 

In C++/Java programmers are allowed to define 

overloaded functions/methods. 

The right function definition (for a given call) is selected 

by the compiler based on type information.

Polymorphism – Ad hoc 

Idiosyncracies: 

C++ allows overloading of operators 

But overloaded definitions cannot change associativity, 

precedence or arity – Why? 

Consider the expression 3+4.5 

How is this is evaluated in C? 

Is this overloading or coercion? 

Exercise: Find out what gcc does. 

Referred to as ad-hoc polymorphism 

Because it is syntactic – can be rewritten as 

separate types 

Leads to syntactic reuse 


Polymorphism - Universal 

Universal polymorphism is divided into 

two kinds: 

Parametric Polymorphism 

e.g. In Pascal / C NULL : forall(Y) Pointer(Y) 

Wait for more on this! 

Inclusion Polymorphism 

e.g. Subrange types in Pascal 

type minutes = 0..60; 

Given, 

5 : minutes; 5 : integer; 

More on this as well! 


Polymorphism - Parametric 

Consider the definition of IntList: 

IntList = EmptyList ⊕ (Int x IntList) 

This can be generalized to: 

List = Forall(Y) EmptyList ⊕ (Y x List(Y)) 

Can Y be any type? 

What if Y is List? (map this into Russel's paradox?) 

Examples: 

Templates in C++ 

Generics in Java (1.5) 

What is the use? 

Re-use 

Compare this with Overloading! 



Example 

length: forall(E) List(E) int 

C++ code 

template 

int length(List head) { 

if (head == NULL) return 0; 

else return 1+length(head->next); 

} 



filter = λ f. λ ls. IF (empty? ls) 

emptyList 

(IF (f (first ls)) 

(filter f (rest ls)) 

(cons (first ls) (filter f (rest ls)))) 

filter: forall(E) Eboolean, List(E) List(E) 

Compare this what we can derive w/o polymorphism! 

Anytype -> boolean, List List 

Dynamic Typing vs. Static Typing Issues 



Consider the type of a sort function. 

sort : IntList IntList 

Generalize this to 

sort : Forall(Y) List(Y) List(Y) 

But what about the comparison operation on 

elements of Y? 

That would be of the form 

compare : Y x Y Bool for any Y. 

So, sort will take an additional argument: the 

function compare. 

sort : Forall(Y) List(Y) x (Y x Y Bool) List(Y) 


Polymorphism – Parametric Existentials 

Recall that Existential Quantification captures 

encapsulation. 

Can we combine Existentials and Universals? 

e.g. recall the ADT List 

PackList = Exists(Y) Y x (Y Int) 

is the type of ADT List where Y is the hidden representation; 

and 

PackList with Y = ArrayZ 

is the type of ADT List with ArrayZ as the representation. 

We can abstract out element type of "ArrayZ" 

ParamPackList = Forall(Z) Exists(Y) Y(Z) x (Y(Z) Int) 

All combinations are feasible: 

Z=int, Y=array; Z=int, Y=linkedlist; Z=student,Y=array;

Polymorphism – Parametric Existentials 

Template Collection Classes in C++ 

Standard Template Library 

Generic Collections in Java 

E.g in Java like syntax 

class Hashtable { 

private (LinkedList)[] table; 

private int hash(K key) { .. } 

public void put(K key, V value) { .. } 

.. 

} 

Hashtable h; 


Polymorphism - Subtyping/Inclusion 

Denote "A is a subtype of B" by A

Polymorphism - Subtyping 

Given function types A1B1 and A2B2 

when one of them is the subtype of the other? 

Given 

type Digit = 0..9; 

type Bit = 0..1; 

type DigitChar = '0'..'9'; 

Conisder the function type 

type P = Digit Char 

and the function types: 

type F = Digit DigitChar 

type G = Bit Char 

type H = Int DigitChar 

Is F


Consider function superPrint defined by 

superPrint(p:P, d:Digit) = { Char c := p(d); } 

P = Digit Char 

F = Digit DigitChar 

What happens to 

superPrint(f, 5) where f:F ? 

Evaulating f(5) is fine since 5:Digit and f accepts 

any Digit. 

f(5) returns a DigitChar and 

assigning c := f(5) is fine since c can be assigned 

any Char (including DigitChar). 

Empirical Conclusion - F


P = Digit Char 

G = Bit Char 

Is G

Subtyping - Rules 

Function Subtyping Rule: 

A1B1


Subtyping and Structures 

Consider 

type Point = struct { x:Int, y:Int }; 

And 

type ColorPoint = struct { x:Int, y:Int, c:Color }; 

Intuitively, all ColorPoints are Points since they 

include x:Int and y:Int fields 

So, model Point and ColorPoint as follows: 

Point = { (('x',x),('y',y))| x:Int, y:Int } 

ColorPoint = 

{ (('x',x),('y',y)) | (('x',x),('y',y)) is a member of Point 

with additional attribute c:Color }


Then the general subtyping rule for structures 

says, given 

T1 = { a1:A1, a2:A2, ..., an:An } where each ai is 

unique and 

T2 = { b1:B1, b2:B2, ..., bm:Bm } where each bi is 

unique, then 

T1

Adobe PDF

Create successful ePaper yourself

Delete template?

Save as template?