1. 5/15/2015IT 3271 Polymorphism (Ch 8) n A functions that is not fixed is polymorphic n Applies to a wide variety of language features n Most languages have at least a little Scope (Ch 10) n A scope of an identifier (e.g., a variable) is the space where it can be recognized. Where do you live? Where to find you? Who are you? What do you do now?

2. 5/15/2015IT 3272 Polymorphism Example : int f(char a, char b) { return a==b; } -fun f(a, b) = (a = b); ML: C: Every thing is fixed: val f = fn : ''a * ''a -> bool

3. 5/15/2015IT 3273 Common Examples of Polymorphism n Overloading n Parameter coercion n Parametric polymorphism n Subtype polymorphism n (OOP) (Dynamic binding)

4. 5/15/2015IT 3274 Overloading n An overloaded function or operator is one that has at least two definitions. (some restriction, what is it?) n Most PL’s have overloaded operators n Some also allow the programmer to redefine overloaded operators

5. 5/15/2015IT 3275 Predefined Overloaded Operators Pascal: a := 1 + 2; b := 1.0 + 2.0; c := "hello " + "there"; d := ['a'..'d'] + ['f'] ML: val x = 1 + 2; val y = 1.0 + 2.0;

6. 5/15/2015IT 3276 Defining Overloaded Functions C++ allows a function to be overloaded int square(int x) { return x*x; } double square(double x) { return x*x; }

7. 5/15/2015IT 3277 Adding new definitions to Overloaded Operators C++ allows operators to be overloaded. class complex { double rp, ip; // real part, imaginary part public: complex(double r, double i) {rp=r; ip=i;} friend complex operator +(complex, complex); friend complex operator *(complex, complex); }; void f(complex a, complex b, complex c) { complex d = a + b * c; … }

8. 5/15/2015IT 3278 Implementing Overloading n Compilers usually implement overloading straightforwardly: – Give a different name to each definition

9. 5/15/2015IT 3279 Coercion n A coercion is an automatic and implicit type conversion double x; x = (double) 2; double x; x = 2; Explicit type conversion in Java: Coercion in Java:

10. 5/15/2015IT 32710 void f(double x) { … } f((byte) 1); f((short) 2); f('a'); f(3); This f can be called with any type of parameter, as long as Java is willing to coerce to type double Parameter Coercion

11. 5/15/2015IT 32711 Defining Type Coercions n Some old languages like Algol 68 and PL/I, have very extensive powers of coercion n Some, like ML, have none n Most, like Java, are somewhere in the middle They wanted to make PLs smart We wanted make PLs precise Must be defined precisely in details about which coercions are performed

12. 5/15/2015IT 32712 Where is my penny? double payment, price, change; int i; cout << "Input two real numbers for payment and price: "; cin >> payment >> price; cout << "Payment = " << payment << ", Price = " << price << endl; change = payment-price ; cout << "Change = " << change << endl; cout << "Change*100 = " << change*100 << "\n\n"; i = (payment-price)*100 ; cout << "(Payment-Price)*100 = " << i << endl; Input two real numbers for payment and price: 20.0 3.99 Payment = 20, Price = 3.99 Change = 16.01 Change*100 = 1601 (Payment-Price)*100 = 1600 There is a criminal charge in 1970’s Input two real numbers for payment and price: 100.0 3.99 Payment = 100, Price = 3.99 Change = 96.01 Change*100 = 9601 (Payment-Price)*100 = 9601 (x-y)*100  (x*100)-(y*100) Input two real numbers for payment and price: 10.0 3.99 Payment = 10, Price = 3.99 Change = 6.01 Change*100 = 601 (Payment-Price)*100 = 601

13. 5/15/2015IT 32713 Difference between Coercion and Overloading: Overloading : type  definition (types determine which definitions) Coercion: definition  type (definitions determine which types) int square(int x) { return x*x; } double square(double x) { return x*x; } void f(int x, int y) { … } square(0.3) f('a', 'b')

14. 5/15/2015IT 32714 Parametric Polymorphism C++ Function Templates template X max(X a, X b) { return a > b ? a : b; } JAVA Generic Classes public interface Queue { boolean offer(T item); T remove(); T poll();..... }

15. 5/15/2015IT 32715 Example: ML Functions - fun identity x = x; val identity = fn : 'a -> 'a - fun reverse x = = if null x then nil = else (reverse (tl x)) @ [(hd x)]; val reverse = fn : 'a list -> 'a list

16. 5/15/2015IT 32716 Subtype Polymorphism n Especially object-oriented languages. Vehicle SUV Honda Pilot Object Number Integer Double Base type Derived type Java Any SUV is a Vehicle

17. 5/15/2015IT 32717 Static  Dynamic Polymorphism Contemporary emphasis Compiling  Running When to be determined:

18. 5/15/2015IT 32718 Scope: the space for a name to be identified n Scope is trivial if you have a unique name for everything: n The same names are used over and over, we in most cases have no problems with that. n How does this work? There are 300M people in the USA

19. 5/15/2015IT 32719 Definitions n When there are different variables using the same name, there are different possible bindings (definitions) for those names type names, constant names, function names, etc. n Each occurrence must be bound using one of the definitions. Which one? n There are many different ways to solve this scoping problem (i.e., how to bind)

20. 5/15/2015IT 32720 The origin of the scoping problem came from logic  x  y(  x  zP(x,y,z)   x(Q(x,y)   z  t(R(y,z,z)  xS(t,x)))  T(x))  x  y(  a  zP(a,y,z)   b(Q(b,y)   c  t(R(y,c,c)  dS(t,d)))  T(x))  -conversion

21. 5/15/2015IT 32721 Scoping with blocks Different ML Blocks The let is just a block: no other purpose A fun definition includes a block: n Multiple alternatives have multiple blocks: n Each rule in a match is a block: fun cube x = x*x*x; fun f (a::b::_) = a+b | f [a] = a | f [] = 0; case x of (a,0) => a | (_,b) => b let val.. in.... end

22. 5/15/2015IT 32722 Java Blocks n In Java and other C-like languages: a compound statement using { and } n A compound statement also serves as a block: while (i < 0) { int c = i*i*i; p += c; q += c; i -= step; } for (int i=0;i<0; i++) { int c = i*i*i; p += c; q += c; i -= step; } int c = 4; // can ?

23. 5/15/2015IT 32723 Nesting Example let end val n = 1 in end Scope of this definition let val n = 2 in n

24. 5/15/2015IT 32724 Labeled Namespaces n ML’s structure… structure Fred = struct val a = 1; fun f x = x + a; end; Fred.f or Fred.a

25. 5/15/2015IT 32725 C++ Labeled Namespaces namespace IT { int a=2; int f(...) {...} }..... { using namespace IT;... a............... f(...).. }..... using IT::f;..... IT::f(...).....

26. 5/15/2015IT 32726 Java or C++ Example Month.min and Month.max public class Month { public static int min = 1; public static int max = 12; … }

27. 5/15/2015IT 32727 Namespace Refinement n Some information and implementation can (may) be hidden in a namespace. Need for OOP. Origin of OOP: abstract data types reveals an interface hides implementation details…

28. 5/15/2015IT 32728 Example: An Abstract Data Type namespace dictionary contains a constant definition for initialSize a type definition for hashTable a function definition for hash a function definition for reallocate a function definition for create a function definition for insert a function definition for search a function definition for delete end namespace Interface definitions should be visible Implementation definitions should be hidden

29. 5/15/2015IT 32729 Two Approaches n C++ makes every component in a namespace visible n ML uses a separate construct to define the interface (a signature in ML) n Java combines the two approaches

30. 5/15/2015IT 32730 Legitimate but not a good idea - val int = 3; val int = 3 : int - fun f int = int*int; val f = fn : int -> int - f 3; val it = 9 : int int is not reserved in ML but....

31. 5/15/2015IT 32731 Primitive Namespaces n ML’s syntax can keep types and expressions separated n There is a separate namespace for types fun f(int:int) = (int:int)*(int:int); These are types in the namespace for types These are variable s in the ordinary namespace

32. 5/15/2015IT 32732 Primitive Namespaces n Not explicitly created by the programmers (like primitive types) n They are part of the language definition n Some languages have several separate primitive namespaces

33. 5/15/2015IT 32733 When Is Scoping Resolved? n All scoping tools we have seen so far are static, i.e., they are determined at compile time n Some languages postpone the decision until runtime: dynamic scoping

34. 5/15/2015IT 32734 Dynamical Scoping n Each function has an environment of definitions n If a name that occurs in a function is not found in its environment, its caller’s environment is searched n And if not found there, the search continues back through the chain of callers n This generates a rather odd scope. Well, not that odd.

35. 5/15/2015IT 32735 Classic Dynamic Scope Rule 1. From the point of definition to the end of the function in which the definition is defined, plus 2. the scope of any functions that call the function, (even indirectly)— minus the scopes of any re-definitions of the same name in those called functions The scope of a definition:

36. 5/15/2015IT 32736 Static vs. Dynamic n The static rule considers only the regions of program text (context of the program), so it can be applied at compile time n The dynamic considers the runtime events: “functions when they are called…” (timing)

37. 5/15/2015IT 32737 Block Scope (Static) With block scope, the reference to inc is bound to the previous definition in the same block. The definition in f ’s caller’s ( h ’s) evironment is inaccessible. fun g x = let val inc = 1; fun f y = y+inc; fun h z = let val inc = 2; in f z end; in h x end; 1 5 5 5 5 5 5 g 5 What is the value of g 5 using ML’s classical block scope rule? = 6

38. 5/15/2015IT 32738 Dynamic Scope With dynamic scope, the reference to inc is bound to the definition in the caller’s ( h ’s) environment. g 5 = 7 if ML used dynamic scope fun g x = let val inc = 1; fun f y = y+inc; fun h z = let val inc = 2; in f z end; in h x end; 2 5 5 5 5 5 5 caller

39. 5/15/2015IT 32739 Dynamic Scope n Only in a few languages: some dialects of Lisp and APL n Available as an option in Common Lisp n Drawbacks: – Difficult to implement efficiently – Creates large and complicated scopes, since scopes extend into called functions – Choice of variable name in caller can affect behavior of called function

40. 5/15/2015IT 32740 Separate Compilation n Scope issues extend to the linker: it needs to connect references to definitions across separate compilations n Special support for this is needed

41. 5/15/2015IT 32741 C Approach, Compiler Side n Two different kinds of definitions: – Full definition – Name and type only: a declaration (prototype) If several separate compilations want to use the same integer variable x : – Only one will have the full definition, int x = 3; – All others have the declaration extern int x;

42. 5/15/2015IT 32742 C Approach, Linker Side n When the linker runs, it treats a declaration as a reference to a name defined in some other file n It expects to see exactly one full definition of that name n Note that the declaration does not say where to find the definition—it just requires the linker to find it somewhere

43. 5/15/2015IT 32743 Older Fortran Approach, Compiler Side Older Fortran dialects used COMMON blocks All separate compilations give the same COMMON declaration: COMMON A,B,C COMMON A,B,C A = B+C/2; COMMON X,A,B B = X - A;

44. 5/15/2015IT 32744 Older Fortran Approach, Linker Side The linker allocates just one block of memory for the COMMON variables: n The linker does not use the local names COMMON A,B,C A = B+C/2; COMMON X,A,B B = X - A; A B C X A B

45. 5/15/2015IT 32745 Modern Fortran Approach A MODULE can define data in one separate compilation A USE statement can import those definitions into another compilation USE says what module to use, but does not say what the definitions are n Unlike the C approach, the Fortran compiler must at least look at the result of that separate compilation