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.

04/18/23 IT 327 1

Polymorphism (Ch 8)

A functions that is not fixed is polymorphic Applies to a wide variety of language features Most languages have at least a little

Scope (Ch 10)

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?

04/18/23 IT 327 2

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

04/18/23 IT 327 3

Common Examples of Polymorphism

Overloading Parameter coercion Parametric polymorphism Subtype polymorphism (OOP) (Dynamic binding)

04/18/23 IT 327 4

Overloading

An overloaded function or operator is one that has at least two definitions.

(some restriction, what is it?)

Most PL’s have overloaded operators Some also allow the programmer to redefine

overloaded operators

04/18/23 IT 327 5

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;

04/18/23 IT 327 6

Defining Overloaded Functions

C++ allows a function to be overloaded

int square(int x) { return x*x;}

double square(double x) { return x*x;}

04/18/23 IT 327 7

Adding new definitions to Overloaded Operators

C++ allows operators to be overloaded.

class complex { double rp, ip; // real part, imaginary partpublic: 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; …}

04/18/23 IT 327 8

Implementing Overloading

Compilers usually implement overloading straightforwardly:

– Give a different name to each definition

04/18/23 IT 327 9

Coercion

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:

04/18/23 IT 327 10

void f(double x) { …}

f((byte) 1);f((short) 2);f('a');f(3);

This f can be called with any typeof parameter, as long as Javais willing to coerce to type double

Parameter Coercion

04/18/23 IT 327 11

Defining Type Coercions

Some old languages like Algol 68 and PL/I, have very extensive powers of coercion

Some, like ML, have none

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

04/18/23 IT 327 12

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.99Payment = 20, Price = 3.99Change = 16.01Change*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.99Payment = 100, Price = 3.99Change = 96.01Change*100 = 9601

(Payment-Price)*100 = 9601

(x-y)*100 (x*100)-(y*100)

Input two real numbers for payment and price: 10.0 3.99Payment = 10, Price = 3.99Change = 6.01Change*100 = 601

(Payment-Price)*100 = 601

04/18/23 IT 327 13

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')

04/18/23 IT 327 14

Parametric Polymorphism

C++ Function Templates

template<class X> X max(X a, X b) { return a > b ? a : b;}

JAVA Generic Classes

public interface Queue<T> {boolean offer(T item);

T remove(); T poll();

.....}

04/18/23 IT 327 15

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

04/18/23 IT 327 16

Subtype Polymorphism Especially object-oriented languages.

Vehicle

SUV Honda Pilot

Object

Number

IntegerDouble

Base type

Derived type

Java

Any SUV is a Vehicle

04/18/23 IT 327 17

Static Dynamic

Polymorphism

Contemporary emphasis

Compiling Running

When to be determined:

04/18/23 IT 327 18

Scope: the space for a name to be identified

Scope is trivial if you have a unique name for everything:

The same names are used over and over, we in most cases have no problems with that.

How does this work?

There are 300M people in the USA

04/18/23 IT 327 19

Definitions

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.

Each occurrence must be bound using one of the definitions. Which one?

There are many different ways to solve this scoping problem (i.e., how to bind)

04/18/23 IT 327 20

The origin of the scoping problem came from logic

xy(xzP(x,y,z) x(Q(x,y)zt(R(y,z,z)xS(t,x)))T(x))

xy(azP(a,y,z) b(Q(b,y)ct(R(y,c,c)dS(t,d))) T(x))

-conversion

04/18/23 IT 327 21

Scoping with blocks Different ML Blocks

The let is just a block: no other purpose A fun definition includes a block:

Multiple alternatives have multiple blocks:

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

04/18/23 IT 327 22

Java Blocks In Java and other C-like languages:

a compound statement using { and } 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 ?

04/18/23 IT 327 23

Nesting Example

let

end

val n = 1in

end

Scope of this definition

Scope of this definition

let val n = 2in n

04/18/23 IT 327 24

Labeled Namespaces

ML’s structure…

structure Fred = struct val a = 1; fun f x = x + a;end;

Fred.f or Fred.a

04/18/23 IT 327 25

C++ Labeled Namespaces

namespace IT {

int a=2;

int f(...) {...}

}.....{ using namespace IT; ... a ... ........ .... f(...)..

}.....

using IT::f;...............IT::f(...) ...............

04/18/23 IT 327 26

Java or C++ Example

Month.min and Month.max

public class Month { public static int min = 1; public static int max = 12; …}

04/18/23 IT 327 27

Namespace Refinement

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…

04/18/23 IT 327 28

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 deleteend namespace

Interface definitions should be visible

Implementation definitionsshould be hidden

04/18/23 IT 327 29

Two Approaches

C++ makes every component in a namespace visible

ML uses a separate construct to define the interface (a signature in ML)

Java combines the two approaches

04/18/23 IT 327 30

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....

04/18/23 IT 327 31

Primitive Namespaces

ML’s syntax can keep types and expressions separated

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

04/18/23 IT 327 32

Primitive Namespaces

Not explicitly created by the programmers (like primitive types)

They are part of the language definition

Some languages have several separate primitive namespaces

04/18/23 IT 327 33

When Is Scoping Resolved?

All scoping tools we have seen so far are static, i.e., they are determined at compile time

Some languages postpone the decision until runtime: dynamic scoping

04/18/23 IT 327 34

Dynamical Scoping Each function has an environment of definitions

If a name that occurs in a function is not found in its environment, its caller’s environment is searched

And if not found there, the search continues back through the chain of callers

This generates a rather odd scope. Well, not that odd.

04/18/23 IT 327 35

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:

04/18/23 IT 327 36

Static vs. Dynamic

The static rule considers only the regions of program text (context of the program), so it can be applied at compile time

The dynamic considers the runtime events: “functions when they are called…” (timing)

04/18/23 IT 327 37

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 ofg 5 using ML’s classicalblock scope rule?

= 6

04/18/23 IT 327 38

Dynamic Scope

With dynamic scope,the reference to inc isbound to the definition in the caller’s (h’s) environment.

g 5 = 7 if ML useddynamic 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

04/18/23 IT 327 39

Dynamic Scope Only in a few languages: some dialects of

Lisp and APL Available as an option in Common Lisp 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

04/18/23 IT 327 40

Separate Compilation

Scope issues extend to the linker: it needs to connect references to definitions across separate compilations

Special support for this is needed

04/18/23 IT 327 41

C Approach, Compiler Side

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;

04/18/23 IT 327 42

C Approach, Linker Side

When the linker runs, it treats a declaration as a reference to a name defined in some other file

It expects to see exactly one full definition of that name

Note that the declaration does not say where to find the definition—it just requires the linker to find it somewhere

04/18/23 IT 327 43

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;

04/18/23 IT 327 44

Older Fortran Approach, Linker Side The linker allocates just one block of memory for

the COMMON variables: 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

04/18/23 IT 327 45

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

Unlike the C approach, the Fortran compiler must at least look at the result of that separate compilation