Ti1220 Lecture 7: Polymorphism

Lecture 6: Polymorphism

TI1220 2012-2013
Concepts of Programming Languages

Eelco Visser / TU Delft

Robin Milner is generally regarded as having
made three major contributions to computer
science. He developed LCF, one of the ﬁrst tools for
automated theorem proving. The language he
developed for LCF, ML, was the ﬁrst language with
polymorphic type inference and type-safe
exception handling. In a very different area, Milner
also developed a theoretical framework for
analyzing concurrent systems, the calculus of
communicating systems (CCS), and its successor, the
pi-calculus. At the time of his death, he was working
on bigraphs, a formalism for ubiquitous computing
subsuming CCS and the pi-calculus.[9]

http://en.wikipedia.org/wiki/Robin_Milner

Outline

Control abstraction

Polymorphism

Lab & Exam

Control Abstraction with
Higher-Order Functions

Higher-order functions

• reducing code duplication, simplifying client code
Currying

• partial function applications
Writing new control structures

• growing the language
By-name parameters

• lazy evaluation

Search for ﬁles that end in ...

object FileMatcher {
private def filesHere = (new java.io.File(".")).listFiles
def filesEnding(query: String) =
for(file <- filesHere; if file.getName.endsWith(query))
yield file
}

Search for ﬁles that match a query ...

for(file <- filesHere; if file.getName.endsWith(query))
yield file

def filesContaining(query: String) =
for(file <- filesHere;if file.getName.contains(query))
yield file

def filesRegex(query: String) =
for(file <- filesHere;if file.getName.matches(query))
yield file

def filesMatching(query: String, method) =
for(file <- filesHere;if file.getName.method(query))
yield file

Find the common pattern

Using a higher-order function

def filesMatching(query: String,
matcher: (String, String) => Boolean) = {
for (file <- filesHere; if matcher(file.getName, query))
yield file
}

filesMatching(query, (x:String,y:String) => x.endsWith(y))
filesMatching(query, _.contains(_))
filesMatching(query, _.matches(_))

Using a higher-order function

def filesMatching(query: String,
matcher: (String, String) => Boolean) = {
for (file <- filesHere; if matcher(file.getName, query))
yield file
}

filesMatching(query, _.endsWith(_))
filesMatching(query, _.contains(_))
filesMatching(query, _.matches(_))

Using closures

object FileMatcher {
private def filesHere = (new java.io.File(".")).listFiles

private def filesMatching(matcher: String => Boolean) =
for (file <- filesHere; if matcher(file.getName))
yield file

filesMatching(_.endsWith(query))
filesMatching(_.contains(query))
filesMatching(_.matches(query))
}

def containsNeg(nums: List[Int]): Boolean = {
var exists = false
for (num <- nums)
if (num < 0)
exists = true Using explicit iteration
exists
}

scala> containsNeg(List(1, 2, 3, 4))
res3: Boolean = false

scala> containsNeg(List(1, 2, -3, 4))
res5: Boolean = true

def containsNeg(nums: List[Int]) = nums.exists(_ < 0)

Using higher-order iteration

def containsOdd(nums: List[Int]): Boolean = {
var exists = false
for (num <- nums)
if (num % 2 == 1)
exists = true
exists
}

def containsOdd(nums: List[Int]) = nums.exists(_ % 2 == 1)

Explicit vs higher-order iteration

scala> def plainOldSum(x: Int, y: Int) = x + y
plainOldSum: (x: Int,y: Int)Int

scala> plainOldSum(1, 2) Currying
res8: Int = 3

scala> def curriedSum(x: Int)(y: Int) = x + y
curriedSum: (x: Int)(y: Int)Int

scala> curriedSum(1)(2)
res9: Int = 3

scala> def first(x : Int) = (y : Int) => x + y
first: (x: Int)(Int) => Int

scala> val second = first(1)
second: (Int) => Int = <function1>

scala> second(2)
res12: Int = 3

Currying
scala> val onePlus = curriedSum(1)_
onePlus: (Int) => Int = <function1>

scala> onePlus(2)
res13: Int = 3

scala> val twoPlus = curriedSum(2)_
twoPlus: (Int) => Int = <function1>

scala> twoPlus(2)
res14: Int = 4

scala> def twice(op: Double => Double, x: Double) = op(op(x))
twice: (op: (Double) => Double, x: Double)Double

scala> twice(_ + 1, 5)
res15: Double = 7.0

scala> twice((x: Double) => x + 1, 5)
res15: Double = 7.0

Making new control structures

Loan Pattern: encapsulate allocation
and de-allocation of resources

def withPrintWriter(file: File, op: PrintWriter => Unit) {
val writer = new PrintWriter(file)
try {
op(writer)
} finally {
writer.close()
}
}

withPrintWriter(
new File("date.txt"),
writer => writer.println(new java.util.Date)
)

scala> println("Hello, world!")
Hello, world!

scala> println { "Hello, world!" }
Hello, world!

Curly braces as function call

def withPrintWriter(file: File)(op: PrintWriter => Unit) {
val writer = new PrintWriter(file)
try {
op(writer)
} finally {
writer.close()
}
}

val file = new File("date.txt")
withPrintWriter(file) { writer =>
writer.println(new java.util.Date)
}

Loan pattern using curried
higher-order functions

How to defer evaluation?

var assertionsEnabled = true
def myAssert(predicate: () => Boolean) =
if (assertionsEnabled && !predicate())
throw new AssertionError

myAssert(() => 5 > 3)

myAssert(5 > 3) // Won’t work, because missing () =>

Function arguments are
evaluated eagerly

def boolAssert(predicate: Boolean) =
if (assertionsEnabled && !predicate)

scala> boolAssert(5 > 3)

scala> assertionsEnabled = false
assertionsEnabled: Boolean = false

scala> boolAssert(10 / 0 == 0)
java.lang.ArithmeticException: / by zero
at .<init>(<console>:8)

def byNameAssert(predicate: => Boolean) =
if (assertionsEnabled && !predicate)

scala> byNameAssert(5 > 3)

scala> byNameAssert(10 / 0 == 0)

By-name parameters
are evaluated on demand

Re-occurring patterns

• transform every element of a list
• verify property of all elements of a list
• extract elements satisfying some criterion
• combining elements of a list using some
operator
Higher-order functions

• direct, reusable deﬁnitions of such patterns

Lecture 4
type
Bool x, y;
x && y
x || y
!x
operations

data type: a collection of data values and a set
of predeﬁned operations on those values

Lecture 4
type checking: the activity of ensuring that
the operands of an operation are of compatible
types.

A compatible type is one that either is legal
for the operator or is allowed under language
rules to be implicitly converted (coerced) to
a legal type

type error: the application of an operator
to an operand of an inappropriate type.

Type Compatible = Type Equal
limits code reuse

Monomorphic Functions

def map(xs: IntList, f: Int => Int): IntList = xs match {
case Nil() => Nil()
case Cons(y, ys) => Cons(f(y), map(ys, f))
}

def inc(xs: IntList) = map(xs, ((x:Int) => x + 1))

def square(xs: IntList) = map(xs, ((x:Int) => x * x))

Repeat pattern for each type

In computer science, polymorphism is a programming
language feature that allows values of different data types
to be handled using a uniform interface.
The concept of parametric polymorphism applies to both
data types and functions.
A function that can evaluate to or be applied to values of
different types is known as a polymorphic function.
A data type that can appear to be of a generalized type
(e.g., a list with elements of arbitrary type) is designated
polymorphic data type like the generalized type from which
such specializations are made.

Polymorphism

Inclusion polymorphism

Parametric polymorphism

Overloading

In object-oriented programming, subtype
polymorphism or inclusion
polymorphism is a concept in type theory
wherein a name may denote instances of many
different classes as long as they are related by
some common super class. Inclusion
polymorphism is generally supported through
subtyping, i.e., objects of different types are
entirely substitutable for objects of another type
(their base type(s)) and thus can be handled via
a common interface.

http://en.wikipedia.org/wiki/Polymorphism_(computer_science)

Type T is a set of values with some operations.

A subtype of T is a subset of the values of
type T, and therefore may be used in a context
where a value of type T is expected.

C: char,int subtype-of long

float subtype-of double

If S subtype-of T, then

Every value of S is also a value of T

A value in S can be used where a value of
type T is expected

Operations of T can be applied to values in S
(S inherits the operations)

Liskov Substitution Principle

Substitutability is a principle in object-oriented
programming. It states that, in a computer program, if
S is a subtype of T, then objects of type T may be
replaced with objects of type S (i.e., objects of type S
may be substituted for objects of type T) without
altering any of the desirable properties of that
program (correctness, task performed, etc.).

http://en.wikipedia.org/wiki/Liskov_substitution_principle

Context:
- e has type T1
- var x: T2 = e
- def f(x: T2) and f(e)

Is T1 compatible with T2?
T1 is a subtype of T2: safe,
by substitutability
T1 is not a subtype of T2:
requires run-time type check

TypePoint = Point(Double x Double)
+ Circle(Doube x Double x Double)
+ Rectangle(Double x Double x Double x Double)

class Point {
protected double x, y;
public void draw() { /* ... */ }
}
Subtype and Inheritance in Java
class Circle extends Point {
private double r;
}

class Rectangle extends Point {
private double w, h;
}

Point p;
p = new Point(3.0, 4.0);
p = new Circle(3.0, 4.0, 5.0);

class BaseTest {
public static void main(String[] args) {
Base base1 = new Base(45);
class Base { Base base2 = new Child(567, 245);
Integer x; base1.print();
base2.print();
public Base(Integer v) { }
x = v; }
}
public void print() {
System.out.println("Base: " + x);
}
}
class Child extends Base {
Integer y;
public Child(Integer v1, Integer v2) {
super(v1);
y = v2;
}
public void print() {
System.out.println("Child: (" + x + "," + y + ")");
}
}
Dynamic Dispatch in Java

Prototype Inheritance
in JavaScript

objects in JavaScript are dynamically
composed without class blueprints

dynamic structural subtyping

In computer programming with object-oriented
programming languages, duck typing is a style of
dynamic typing in which an object's methods and properties
determine the valid semantics, rather than its inheritance
from a particular class or implementation of a speciﬁc
interface.

When I see a bird that walks like a duck and swims like
a duck and quacks like a duck, I call that bird a duck.
James Whitcomb Riley

http://en.wikipedia.org/wiki/Duck_typing

objects in JavaScript inherit
from a prototype object

Object.create()

var o1 = Object.create({x:1, y:2});
// o1 inherits properties x and y.

var o2 = Object.create(null);
// o2 inherits no props or methods.

var o3 = Object.create(Object.prototype);
// o3 is like {} or new Object().

var p = {x:1};
// Define a prototype object.

var o = Object.create(p);
// Create an object with that prototype.

p.isPrototypeOf(o)
// => true: o inherits from p

Object.prototype.isPrototypeOf(p)
// => true: p inherits from Object.prototype

The prototype Attribute

Inheritance
var o = {}
// o inherits object methods from Object.prototype
o.x = 1;
// and has an own property x.
var p = Object.create(o);
// p inherits properties from o and Object.prototype
p.y = 2;
// and has an own property y.
var q = Object.create(p);
// q inherits properties from p, o, and Object.prototype
q.z = 3;
// and has an own property z.
var s = q.toString();
// toString is inherited from Object.prototype
q.x + q.y
// => 3: x and y are inherited from o and p

var unitcircle = { r:1 };
// An object to inherit from

var c = Object.create(unitcircle);
// c inherits the property r
Inheritance
c.x = 1; c.y = 1;
// c defines two properties of its own

c.r = 2;
// c overrides its inherited property

unitcircle.r;
// => 1: the prototype object is not affected

Classes and Constructors
function Range(from, to) {
this.from = from;
this.to = to;
}
Range.prototype = {
includes : function(x) {
},
foreach : function(f) {
for ( var x = Math.ceil(this.from); x <= this.to; x++) f(x);
},
toString : function() {
}
};
var r = new Range(1, 3); // Create a range object
r.includes(2); // => true: 2 is in the range
r.foreach(console.log); // Prints 1 2 3
console.log(r); // Prints (1...3)

r instanceof Range
// returns true if r inherits
// from Range.prototype

Constructors and Class Identity

var F = function() {}; Constructor Property
// This is a function object.
var p = F.prototype;
// This is the prototype object associated with it.
var c = p.constructor;
// This is the function associated with the prototype.
c === F
// => true: F.prototype.constructor==F for any function
var o = new F();
// Create an object o of class F
o.constructor === F
// => true: the constructor property specifies the class

If all code is written without mention of any
speciﬁc type and thus can be used
transparently with any number of new types,
it is called parametric polymorphism.


A mono-morphic (single-shaped)
procedure can operate only on arguments of
a ﬁxed type.

A poly-morphic (many-shaped) procedure
can operate uniformly on arguments of a
whole family of types.

Parametric polymorphism is a type
system in which we can write polymorphic
procedures.

Polymorphic function: parameterized with types

A => B : type of functions from type A to type B

def map[A,B](xs: List[A], f: A => B): List[B] = xs match {
case List() => List()
case y :: ys => f(y) :: map(ys, f)
}

val l = map(List(1, 2, 3), ((x: Int) => x + 1))

If the function denotes different and potentially
heterogeneous implementations depending on a limited
range of individually speciﬁed types and combination, it is
called ad-hoc polymorphism. Ad-hoc polymorphism
is supported in many languages using function and
method overloading.


Method Overloading

def *(that: Rational): Rational =
new Rational(numer * that.numer, denom * that.denom)

def *(i: Int): Rational =
new Rational(numer * i, denom)

scala> val c = new Rational(3,7)
c: Rational = 3/7
In a method call, the
scala> c * 2
compiler picks the version
res1: Rational = 6/7
of an overloaded method
that correctly matches the
types of the arguments.

Graded Assignment 1
Algebraic datatypes in C
Dynamic dispatch in C

Important dates
Deadline: April 2, 2013 23:59
Extension: April 5, 2013 23:59

Submitting after extension date is not possible
Maximum penalty for submitting after deadline: 6 points
Minimum grade needed: 4
Grade: 70% unit tests, 30% check lists
Grade for GAs: average of four assignments

Syntax and Semantics Quarter 3
Names, Bindings, and Scopes
Storage
Data Types Basics of
Functional Programming Scala
First-class Functions JavaScript
Polymorphism C

Type Parameterization
Parsing and Interpretation
Data Abstraction / Modular Programming
Functional Programming Redux
Concurrency
Concurrent Programming
Quarter 4 Domain-Speciﬁc Languages

Material for exam

Slides from lectures

Tutorial exercises

Sebesta: Chapters 1-3, 5-8

Programming in Scala: Chapters 1, 4-9, 15-16

K&R C: Chapters 1-6

JavaScript Good Parts: Chapters 1-4

Content of exam

20% multiple choice questions
about concepts

40% Scala programming
(functional programming)

20% C programming
(structures and pointers)

20% JavaScript programming
(objects and prototypes)

http://department.st.ewi.tudelft.nl/weblab/assignment/850

Answers will be published when 80
students have completed the exam

Registration for Exam is Required

http://department.st.ewi.tudelft.nl/weblab/assignment/759 → Your Submission

Ti1220 Lecture 7: Polymorphism

Recommended

More Related Content

What's hot (20)

Similar to Ti1220 Lecture 7: Polymorphism (20)

More from Eelco Visser (20)

Ti1220 Lecture 7: Polymorphism