Structure and Abstraction in HOT...
Transcript of Structure and Abstraction in HOT...
![Page 1: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/1.jpg)
26/7/00 Marktoberdorf 1
Structure and Abstraction inHOT Languages
A Comparison of Polymorphism, Modules, and Objects
David MacQueenBell Labs
![Page 2: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/2.jpg)
26/7/00 Marktoberdorf 2
How OO and FP Support Adaptable Programming
Parameterization, Subtyping, Iinheritance
David MacQueenBell Labs
![Page 3: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/3.jpg)
26/7/00 Marktoberdorf 3
Hot Languages
• higher-order– binding code and data
• typed– static type checking (for error detection)– specifying structure of data and program
interfaces– formalism for analyzing language constructs
• functional and object-oriented (OO) paradigms
![Page 4: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/4.jpg)
26/7/00 Marktoberdorf 4
Functional Paradigm
• value-oriented programming -- computing by constructing
• functions as data (closures)• parameterization at value, type, and module level• "algebraic" data types for unions, records for
products• pure vs impure functional languages
– Haskell pure, lazy– ML impure (imperative), strict
![Page 5: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/5.jpg)
26/7/00 Marktoberdorf 5
OO Paradigm
• state-oriented, imperative programming• objects as data (instance state + method
code)• subtyping (based on subclassing)• subclasses for unions, objects for products• pure vs impure object oriented languages
– Smalltalk and Java pure (everything an object)– Eiffel, Modula3, C++, Object Pascal, etc. impure
![Page 6: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/6.jpg)
26/7/00 Marktoberdorf 6
Theme: Static typing good
Static typing, based on a sound type system (“well-typed programs do not go wrong”) is a basic requirement for robust system programming.
![Page 7: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/7.jpg)
26/7/00 Marktoberdorf 7
Why Types?
• safety: well typed programs do not go wrong• a language and disciple for design of data
structures and program interfaces• support for separate development via precise
interfaces• properties and invariants verified by the
compiler (“a priori guarantee of correctness”)• support for orderly evolution of software
– consequences of changes can be traced
![Page 8: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/8.jpg)
26/7/00 Marktoberdorf 8
Types and FP
• In FP, types determine behavior to a much greater extent than in conventional procedural or OO languages.
• OO languages use “modeling languages” like UML. For FP, the type system serves as the modeling language.
• In FP, the extent of program behavior covered by type checking (in Greg Nelson’s terminology) is greater than for imperative programming.
![Page 9: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/9.jpg)
26/7/00 Marktoberdorf 9
A type-based approach
Evaluating language designs on the based of their type systems
• type systems provide a common framework for comparison (synthesis?) of designs
• type systems are a major factor determining the flexibility and expressiveness of language designs
• type systems have been thoroughly studied and provide a connection between language theorists and language designers and users
![Page 10: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/10.jpg)
26/7/00 Marktoberdorf 10
Theme: Program adaptation
To support code reuse, we must be able to build general purpose program units and then adapt them to particular uses.
How do we build generic units, and how do we specialize them, or derive specialized versions?
![Page 11: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/11.jpg)
26/7/00 Marktoberdorf 11
Overview
• Introduction: parameterization, subtyping, inheritance
• Review of Type Systems• Functional Programming (ML)
– functions, polymorphism, modules
• Object-Oriented programming– reconstruction from first principles
• Comparison of OO and FP• Synthesis of OO and FP
![Page 12: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/12.jpg)
26/7/00 Marktoberdorf 12
Adaptation Mechanisms
• parameterization– values: procedures and functions– types: parametric polymorphism
• subtype polymorphism• dynamic dispatch• implementation inheritance: extension and
update of functionality• information hiding, abstraction, modularity
![Page 13: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/13.jpg)
26/7/00 Marktoberdorf 13
Procedural abstraction
• Most basic form of reuse• Name a block of code, call it repeatedly• Preserves env. of definition (closure)
procedure P() =begin x := x+1; y := y*x;end
var x: int; ... P(); ... P(); ...
![Page 14: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/14.jpg)
26/7/00 Marktoberdorf 14
data parameters: 1st order functions
• abstract over names of values• specialize by application to different
arguments
![Page 15: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/15.jpg)
26/7/00 Marktoberdorf 15
data parameters: sorting lists
this can sort different lists of ints, but only with respect to fixed, hardwired ordering <
fun sort(l: int list) = (if null l ... x < y ...) -- code to sort l
sort : int list -> int list
sort [2, 17, -3, 5] => [-3, 2, 5, 17]
![Page 16: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/16.jpg)
26/7/00 Marktoberdorf 16
function parameters: higher-order fns
• abstract over names of functions• specialize by passing functions
fun sort (< : int*int->bool)(l: int list) = (if null l … x < y …)
sort : (int*int->bool) -> int list -> int list
sort (>) [2, 17, -3, 5] => [-3, 2, 5, 17]
![Page 17: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/17.jpg)
26/7/00 Marktoberdorf 17
Type parameters: polymorphic functions
• abstract over names of types• specialize by passing a type argument
![Page 18: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/18.jpg)
26/7/00 Marktoberdorf 18
Polymorphic sort
fun sort [t](<: t*t->bool)(l: t list) =
(if null l ... x < y ...)
sort : ∀t.(t*t->bool) -> t list -> t list
sort[int](>int)[2, 17, -3, 5] => [17, 5, 2, -3]
sort[string](<string)[“bob”, “alice”, “tom”] => [“alice”, “bob”, “tom”]
![Page 19: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/19.jpg)
26/7/00 Marktoberdorf 19
Type parameters: polymorphic sort
Note that if the element type is a parameter, the comparison function < must also be a parameter.
fun sort [t](<: t*t->bool)(l: t list) = (if null l ... x < y ...)
sort : ∀t.(t*t->bool) -> t list -> t list
![Page 20: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/20.jpg)
26/7/00 Marktoberdorf 20
Interface parameters
• Interface specifies a set of components (types and values), defining the type of a module.
• Abstract a module over an interface.
signature Order =sig type t val < : t * t -> boolend
functor Sort(X: Order) =struct fun sort(l: X.t list) = ...
end
![Page 21: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/21.jpg)
26/7/00 Marktoberdorf 21
Subtype polymorphism
• The subtype relation
• Subsumption Rule
A <: B x: A
x: B
A <: B “every A is a B”
Nat <: Int, Ascii <: Unicode
![Page 22: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/22.jpg)
26/7/00 Marktoberdorf 22
Picturing subtyping: A <: B
1 - 1
subset
embedding
B
A
A
B
![Page 23: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/23.jpg)
26/7/00 Marktoberdorf 23
Sources of subtyping
Mathematics: Nat <: Int
Machines: UnsignedInt32 <: Int32 ?
Mathematics: Int <: RealMachines: Int32 <: Float64 (representation shift)
![Page 24: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/24.jpg)
26/7/00 Marktoberdorf 24
Sources of subtyping: records
point = {x: int, y: int}
colorpoint = {x: int, y: int, c: color}
colorpoint <: point
point colorpoint colorpoint’
x xxy yyc
c
![Page 25: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/25.jpg)
26/7/00 Marktoberdorf 25
Using Subtyping
move : Point -> Point
ColorPoint <: Point
cp : ColorPoint
cp : Point
move cp : Point
![Page 26: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/26.jpg)
26/7/00 Marktoberdorf 26
Implementation Inheritance
• A principle adaptation mechanism of OO languages– class-based: subclasses– object-based: cloning + extension + method
update
• Based on “open recursion”replacing members of a family of mutually recursive functions
![Page 27: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/27.jpg)
26/7/00 Marktoberdorf 27
Inheritance
A class and a derived subclassclass Counter(n: Int) var x: Int = n method get() = x method add(y: Int) = x := x + y
class BCounter(max: int) inherits Counter method add(y: Int) = (* override *) if get()+y < max then x := get() + y method inc() = (* extend *) if get() < max-1 then x := get() + 1
![Page 28: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/28.jpg)
26/7/00 Marktoberdorf 28
Open recursion
• conventional closed recursion
f g
h
![Page 29: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/29.jpg)
26/7/00 Marktoberdorf 29
Open recursion
open recursion: replacing members of a recursive family of functions
f g
h
f g’
h
![Page 30: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/30.jpg)
26/7/00 Marktoberdorf 30
Open recursion with function passing
fun f(x) = ... g(-) ... g(-) ...fun g(x) = ... g(-) ... f(-) ...
fun F(f,g)(-) = ...f(-)...g(-)...fun G(f,g)(-) = ...g(-)...f(-)...fun G’(f,g)(-) = ...g(-)...
Old family New familyf = F(f,g) f’ = F(f’,g’)g = G(f,g) g’ = G’(f’,g’)
Requires recursive types.
![Page 31: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/31.jpg)
26/7/00 Marktoberdorf 31
Open recursion with function refs
fr = ref(dummy); gr = ref(dummy)fun f(x) = ... !gr(-) ... !gr(-) ...fun g(x) = ... !gr(-) ... !fr(-) ...fun g’(x) = ... !gr(-) ...
Old familyfr := f; gr := g;... !fr(-) ...
New familygr := g’;
... !fr(-) ...
![Page 32: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/32.jpg)
26/7/00 Marktoberdorf 32
General support for adaptation
• abstraction and information hiding support adaptation by reducing dependencies between program components– e.g. the implementation of an abstract type can
be modified without disturbing clients
• explicit, enforced interfaces support change by allowing the consequences of a change to be easily tracked through a large system
![Page 33: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/33.jpg)
26/7/00 Marktoberdorf 33
II. Type systems
• What is a type?– a set of values
int = {... -2, -1, 0, 1, 2, ...}
– a specification of the form or structure of
values
– a device for controlling how we can act on
values of the type
![Page 34: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/34.jpg)
26/7/00 Marktoberdorf 34
Language of types
• Types are expressed by terms in a type abstract syntax:
A ::= int | A * B | A -> B | ...
E.g. int, int * int, int -> int, int -> (int -> int)
• add constructs to increase power and expressiveness
![Page 35: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/35.jpg)
26/7/00 Marktoberdorf 35
Types and Terms
• Types are related to an underlying language for expressing and manipulating values
e ::= x | fun(x)e | e e’ (implicit)e ::= x | fun(x:A)e | e e’ (explicit)
through typing judgements:
e : A “e has type A”
![Page 36: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/36.jpg)
26/7/00 Marktoberdorf 36
• How do we know the type of a free variable?x: ?
• Answer: typing environmentsC ::= ∅ | C; x: A
(finite mapping from variables to types)
• Contexts are added to typing judgements to deal with free vars
C |- e : A
E.g. x: int; y: bool |- x: int
Typing environments
![Page 37: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/37.jpg)
26/7/00 Marktoberdorf 37
Typing Rules
• deduction rules for typing judgements
C |- e: A -> B C |- e’ : A
C |- e e’ : B(-> Elim)
C; x: A |- e : B
C |- fun(x:A)e : A -> B(-> Intro)
![Page 38: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/38.jpg)
26/7/00 Marktoberdorf 38
Typing rules: atomic expressions
C |- n : Int(n an integer)
C; x: A |- x: A
Integer constants
Variables
(Var)
![Page 39: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/39.jpg)
26/7/00 Marktoberdorf 39
Typing derivations
• proof of a valid typing judgement• laid out as a tree of rule instances
C |- +: int*int -> int
C |- +(x,3) : int
C |- x:int C |- 3:int
C = + : int * int -> int; x: int
Derivation of : C |- +(x,3): int, where
C |- (x,3) : int*int
![Page 40: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/40.jpg)
26/7/00 Marktoberdorf 40
Well-typing
e is well-typed wrt context C if there is a type A such that
C |- e : A
is a valid judgement.
1+3 - well typed wrt context C
1+true - ill typed (true: bool) there is no type A with valid judgement C |- 1+true : A
![Page 41: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/41.jpg)
26/7/00 Marktoberdorf 41
Type Inference
• Type inference (for a term e) is the process of discovering a type A and a derivation of
C |- e : A
![Page 42: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/42.jpg)
26/7/00 Marktoberdorf 42
Multiple typings
• There may be more than one type A such that C |- e : A
• E.g. typing (untyped) identity functionx: Int |- x : Int
∅ |- fun(x)x : Int -> Int
x: Bool |- x : Bool
∅ |- fun(x)x : Bool -> Bool
x: A |- x : A
∅ |- fun(x)x : A -> A
![Page 43: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/43.jpg)
26/7/00 Marktoberdorf 43
References for Type Systems
• Cardelli: “Type Systems” tutorialin library, Cardelli’s web page
• B. Pierce: “Type Systems”forthcoming comprehensive book with
softwaretoolkit
![Page 44: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/44.jpg)
26/7/00 Marktoberdorf 44
Typing and program behavior
• Denotational semantics– [•] : expressions → values– [•] : types → sets of values
• Soundness:∅ |- e: A ⇒ [e] ∈ [A]
• Type errors
[e] = wrong if e contains a type error
e.g. [1+true] = wrong
wrong ∉ [A] for any type A
![Page 45: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/45.jpg)
26/7/00 Marktoberdorf 45
Typing and program behavior
• Operational semantics e e’ single step reduction e ∗ e’ multiple step reduction
• Subject reduction e ∗ e’ and ∅ |- e: A ⇒ ∅ |- e’: A
• Corollary: well-typed expressions don’t get stuck.
1 + true is a stuck expression
![Page 46: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/46.jpg)
26/7/00 Marktoberdorf 46
Some basic type constructs
• products: A * B
• records: {m1:A1,...,mn:An}
• sums: A + B
• functions: A -> B • recursion: µt.A
• refs: Ref A• subtypes: A <: B
![Page 47: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/47.jpg)
26/7/00 Marktoberdorf 47
Products
A * B = {(a,b)| a ∈ A, b ∈ B}
C |- e1 : A
C |- (e1, e2): A * B(* Intro)
C |- e2 : B
C |- fst e : A
C |- e: A * B(* Elim left)
C |- snd e : B
C |- e: A * B(* Elim right)
![Page 48: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/48.jpg)
26/7/00 Marktoberdorf 48
Products
p = (1,true) : Int * Bool
fst p : Int ==> 1
snd p : Bool ==> true
∅ |- 1 : Int
∅ |- (1, true): Int * Bool
∅ |- true : Bool
![Page 49: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/49.jpg)
26/7/00 Marktoberdorf 49
Products
Projections as primitive operationsfor each pair of types A and B:
fst(A,B) : A * B -> A
snd(A,B) : A * B -> B
(.,.)(A,B) : A -> B -> A * B (?)
pairing as a primitive?
![Page 50: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/50.jpg)
26/7/00 Marktoberdorf 50
Records
record = labeled product = finite map from labels to valuesr = {age = 13, name = “Bob”}
record type = finite map from labels to types
r : {age : Int, name : String}
field = labeled component of a record
r.age : Int ==> 13 (field selection)
![Page 51: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/51.jpg)
26/7/00 Marktoberdorf 51
Typing records
C |- {m1=e1,...,mn=en} : {m1:A1,...,mn:An}
C |- ei: Ai (i=1,...,n)
(Record Intro)
C |- e : {m1:A1,...,mn:An}
C |- e.mi: Ai(Record Elim)
Obvious generalization of product rules:
![Page 52: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/52.jpg)
26/7/00 Marktoberdorf 52
Sums
A + B - tagged union of A and B
inl: A -> A + B
outl: A + B -> A
isl: A + B -> Bool
inr: B -> A + B
outr: A + B -> B
isr: A + B -> Bool
Actually, should be: inl(A,B) , etc.
![Page 53: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/53.jpg)
26/7/00 Marktoberdorf 53
Sums
i = inl 3 : Int * Bool (inl(Int,Bool))
b = inr true : Int * Bool
isl b : Bool ==> falseoutl a : Int ==> 1
![Page 54: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/54.jpg)
26/7/00 Marktoberdorf 54
Sums
case(A,B,C) : (A+B) * (A->C) * (B->C) -> C
case(A,B,C)(x,f,g) = if isl x then f(outl x) else g(outr x)
Could replace isl, isr, outl, outr with case
case (a, fun(n)(n+1), fun(b)(if b then 3 else 4)) ==> 2
![Page 55: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/55.jpg)
26/7/00 Marktoberdorf 55
Recursive types
µt.A [or Rec(t)A, Fix(Fun(t)A)]
µt.A = [µt.A/t]A
Equirecursive types:
C |- e: µt.A
C |- e: [µt.A/t]A C |- e: µt.A
C |- e: [µt.A/t]A
![Page 56: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/56.jpg)
26/7/00 Marktoberdorf 56
Isorecursive types
C |- fold e: µt.A
C |- e: [µt.A/t]A
µt.A ↔ [µt.A/t]A
C |- e: µt.A
C |- unfold e: [µt.A/t]A(Rec Elim)
(Rec Intro)
![Page 57: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/57.jpg)
26/7/00 Marktoberdorf 57
Recursive type example: integer lists
List = µt.(Unit + Int * t)
nil = fold(inl()) : List
cons = fun(i:int,x:list)fold(inr(i,x)) : Int * List -> List
hd = fun(x:list) if isr(unfold x)
then fst(outr(unfold x))else errorList
: List -> Int
![Page 58: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/58.jpg)
26/7/00 Marktoberdorf 58
Ref
Ref A -- mutable cells containing A values
Example of a storage type; also arrays and mutable records
refA : A -> Ref A
!A : Ref A -> A (deref)
:=A : Ref A * A -> Unit
![Page 59: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/59.jpg)
26/7/00 Marktoberdorf 59
Ref
r = ref 3 : Ref Int
!r : Int ==> 3
r := 4 : Unit ==> () ( (): Unit )
!r : Int ==> 4
![Page 60: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/60.jpg)
26/7/00 Marktoberdorf 60
The subtype relation
• A <: B
– A is a subset of B: [A] ⊆ [B], or
– There is a canonical injection of [A] into [B] (coercion semantics)
• <: is reflexive, transitive and antisymmetric*
![Page 61: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/61.jpg)
26/7/00 Marktoberdorf 61
Subsumption
the typing rule reflecting the interpretation of subtypes as subsets:
C |- e: A C |- A <: B
C |- e: B
How is C relevant to A <: B?
(Subsumption)
![Page 62: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/62.jpg)
26/7/00 Marktoberdorf 62
Propagation of subtyping
• Products (monotonic)
• Sums (monotonic)
A1 <: A2 B1 <: B2
A1 * B1 <: A2 * B2
A1 <: A2 B1 <: B2
A1 + B1 <: A2 + B2
![Page 63: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/63.jpg)
26/7/00 Marktoberdorf 63
Propogation of subtyping
• function types
When is A1 -> B1 <: A2 -> B2 ?
B2B2
B1A2
A1
![Page 64: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/64.jpg)
26/7/00 Marktoberdorf 64
Function subtyping
B2B2
B1A2
A1
f ∈ A -> B ifx ∈ A ⇒ f x ∈ B
A2 <: A1 B1 <: B2
Assume A2 <: A1 and B1 <: B2.Assume f ∈ A1 -> B1 and x ∈ A2.Then x ∈ A1 ⇒ f x ∈ B1 ⇒ f x ∈ B2.Hence f ∈ A2 -> B2.
![Page 65: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/65.jpg)
26/7/00 Marktoberdorf 65
Subtyping function types
function types– contravariant (antimonotonic) in the domain– covariant (monotonic) in the range.
A2 <: A1 B1 <: B2
A1 -> B1 <: A2 -> B2
![Page 66: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/66.jpg)
26/7/00 Marktoberdorf 66
Subtyping records
Depth subtyping (like products)
{m1:A1,...,mn:An} <: {m1:B1,...,mn:Bn}
Ai <: Bi (i=1,...,n)
{age: Nat, b: Bool} <:{age: Int, b: Bool}
Nat <: Int
![Page 67: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/67.jpg)
26/7/00 Marktoberdorf 67
Subtyping records 2
Width subtyping -- adding fields makes a subtype.
{m1:A1,...,mn+k:An+k} <: {m1:A1,...,mn:An}
{age: Int, name: String, Id: Int} <:{age: Int, name: String}
Intuition: If all you can do to a record is select fields, extra fields don’t get in the way.
![Page 68: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/68.jpg)
26/7/00 Marktoberdorf 68
Subtyping Records
Depth and width subtyping can be combinded.
{age: Nat, name: String, Id: Int} <:{age: Int, name: String}
![Page 69: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/69.jpg)
26/7/00 Marktoberdorf 69
Subtyping Refs
Ref types are invariant!Thm: Ref A <: Ref B ⇒ A = B [B<:A] let r : Ref A and b : B
r : Ref B (assumption) r := b b = !r : A
[A<:B] let r : Ref A and a : A r : Ref B (assumption) r := a a = !r : B
![Page 70: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/70.jpg)
26/7/00 Marktoberdorf 70
Subtyping and recursion 1
• The “Amber” rule:
C, s <: t |- A <: B
C |- µs.A <: µt.B
![Page 71: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/71.jpg)
26/7/00 Marktoberdorf 71
Subtyping and recursion 2
Example:Nat <: Int |- µt.{a: Nat, b: Unit -> t, c: Bool} <: µt.{a: Int, b: Unit -> t}
1. s <: t ⇒2. Unit -> s <: Unit -> t ⇒3. {a: Nat, b: Unit -> s, c: Bool} <: {a: Int, b: Unit -> t}
![Page 72: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/72.jpg)
26/7/00 Marktoberdorf 72
Subtyping and recursion 3
Exercise:NatList = µt.(Unit + Nat * t)
IntList = µt.(Unit + Int * t)
1. Show that NatList <: IntList, assuming Nat <: Int.
List = Fun(s)µt.(Unit + s * t)
2. Show that List is monotonic:
List s <: List t if s <: t.
![Page 73: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/73.jpg)
26/7/00 Marktoberdorf 73
Subtyping and recursion 4
fold and unfold rules (equirecursion)
µs.F(s) = F(µs.F(s)) implies
µs.F(s) <: F(µs.F(s)) (fold)
F(µs.F(s)) <: µs.F(s) (unfold)
![Page 74: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/74.jpg)
26/7/00 Marktoberdorf 74
Parametric Polymorphism
Parameterize expressions over types– Add type variables and quantified types to the
type language
– Add lambda-abstraction over types and type application to the expression language
A ::= ... | t | All(t)A (Cardelli style)
A ::= ... | t | ∀t.A (Classical)
e ::= ... | Fun(t)e | e[t]
e ::= ... | Λt.e | e[t]
![Page 75: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/75.jpg)
26/7/00 Marktoberdorf 75
Parametric Polymorphism: Examples
Examples
Id = Fun(t)fun(x:t)x : All(t)t->t
Id = Λt.λx:t.x : ∀t.t->t
Polymorphic identity function
Self-application combinator (1st class polymorphism)fun(x:All(t)t->t)(x[All(t)t->t])x : (All(t)t->t) -> (All(t)t->t)
Id[Int] : Int -> Int; Id[Int]3 : Int
![Page 76: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/76.jpg)
26/7/00 Marktoberdorf 76
Parametric Polymorphism: Rules
Typing rules
C, t : Type |- e : A
C |- Fun(t)e : All(t)A
C |- e[B] : [B/t]A
C |- e : All(t)A
(All Intro)
(All Elim)
![Page 77: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/77.jpg)
26/7/00 Marktoberdorf 77
Parametric Polymorphism: Semantics
• The meaning of a polymorphic type can be:– the intersection of all its instances, or– a parametric family of types
• parametricity: a polymorphic function Fun(t)e works the same regardless of how t is instantiated (i.e. computations don’t depend on the identity of the type t).– Cor: fun(x)x is the unique (computable)
member of the type (All t)(t -> t).
![Page 78: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/78.jpg)
26/7/00 Marktoberdorf 78
Polymorphic primitive operations
Primitive operations associated with type constructions can be polymorphic
fst: All(s)All(t) s * t -> s
inl: All(s)All(t) s -> s + t
if_then_else: All(s) Bool * s * s -> s
ref: All(s)(s -> Ref s)
:= : All(s)(Ref s * s -> Unit)
but not fold, unfold, r.m !
![Page 79: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/79.jpg)
26/7/00 Marktoberdorf 79
Type functions
Type functions are defined by abstracting over type terms
A ::= ... | Fun(t)A | A(B)
Pair = Fun(t)(t*t)
List = Fun(s)µt.(Unit + s * t)
null = Fun(s)fun(x:List s) isl[Unit][s*List(s)] (unfold x) : All(s)(List s -> Bool)
![Page 80: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/80.jpg)
26/7/00 Marktoberdorf 80
Typing type functions: kinds
Types now need to be well-typed!Types of type terms are called kinds.
K ::= Type | Type -> Type
Int : TypeList : Type -> TypeList(Int) : Type* : Type -> Type -> Type
In C |- e: A, A must be of kind Type.
![Page 81: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/81.jpg)
26/7/00 Marktoberdorf 81
Type system problems
• What can go wrong when designing a type system for a language?– type system is unsound (i.e. inconsistent with the
evaluation semantics)
– type system is undecidable (i.e. can’t find a terminating algorithm for discovering typings)
– type system is incomplete (can’t find typings for “sensible” expressions)
– typings are not canonical (i.e. terms have multiple typings, none of which is “best”)
– type system is too complex or difficult to use to be practical (e.g. not enough inference)
![Page 82: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/82.jpg)
26/7/00 Marktoberdorf 82
III. Functional Programming
![Page 83: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/83.jpg)
26/7/00 Marktoberdorf 83
Essence of Functional Programming
• functions as first-class values– higher-order functions: functions that operate
on, or create, other functions– functions as components of data structures
• value-oriented programming– lego vs the abacus– compute by building and traversing values– values are shareable
• parameterization is a core concept• algebraic types and pattern matching
![Page 84: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/84.jpg)
26/7/00 Marktoberdorf 84
Functional programming history• lambda calculus (Church, 1932)• simply typed lambda calculus (Church, 1940)• lambda calculus as prog. lang. (McCarthy(?),
1960, Landin 1965)• polymorphic types (Girard, Reynolds, early
70s)• algebraic types (Burstall & Landin, 1969)• type inference (Hindley, 1969, Milner, mid
70s)• lazy evaluation (Wadsworth, early 70s)
![Page 85: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/85.jpg)
26/7/00 Marktoberdorf 85
Varieties of Functional Programming• typed (ML, Haskell) vs untyped (scheme,
Erlang)• Pure vs Impure
– impure have state and imperative features– pure have no side effects, “referential
transparency”
• Strict vs Lazy evaluation• Hindley-Milner vs System F typing
– H-M: implicit typing with type inference– System F: explicit type abstraction and appl.
![Page 86: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/86.jpg)
26/7/00 Marktoberdorf 86
A brief introduction to (Core) ML
• strict evaluation• impure
– refs, arrays, imperative I/O, exceptions
• Hindley-Milner type inference• algebraic types with pattern matching
– sums and recursive types via datatypes
![Page 87: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/87.jpg)
26/7/00 Marktoberdorf 87
ML 2
expressions1: int 1.0: realtrue: bool “Bob”: string
(1,2): int * bool{a = true, b = “x”}: {a: int, b: string}
if x<3 then 0 else x+1 : int
(fn x => x+1) : int -> intsquare 3 : int
(print “hello”; 4): int
![Page 88: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/88.jpg)
26/7/00 Marktoberdorf 88
ML 3
• declarationsval x = 3 (* x: int *)
val inc = (fn x => x+1) (* inc: int->int *)fun inc x = x+1
type point = {x: int, y: int} (* type *)type ’a pair = ’a * ’a (* type function *)
let val p : int pair = (2,3) (* a block *) fun inc x = x+1 in inc(#1 p)end : int
![Page 89: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/89.jpg)
26/7/00 Marktoberdorf 89
Algebraic datatypesdatatype tree = Node of int * tree * tree | Leaf of int
val t = Node(3,Leaf 2,Leaf 1)val t : tree
fun depth(Leaf n) = 1 | depth(Node(n,left,right)) =
1+max(depth(left),depth(right)val depth : tree -> int
depth t : int ==> 2
![Page 90: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/90.jpg)
26/7/00 Marktoberdorf 90
Algebraic datatypes: list
datatype ’a list = nil | :: of ’a * ’a list
val a = 2::3::nil (* or [2,3] *)val a : int list
fun length nil = 0 | length (x::xs) = 1 + length xsval length : ’a list -> int
![Page 91: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/91.jpg)
26/7/00 Marktoberdorf 91
Type inference in ML (Hindley-Milner)val id = (fn x => x)
λ
x xα β
γ γ = α → β
α = β
γ = α → α
(fn x => x) : α → α, for any α
id : ’a -> ’a (id : ∀t.t->t)
![Page 92: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/92.jpg)
26/7/00 Marktoberdorf 92
Type inference
@
e e’α β
γα = β → γ
Application expressions
![Page 93: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/93.jpg)
26/7/00 Marktoberdorf 93
The let rule
• Polymorphism is introduced by let declarations
C |- let val x = e in e’ end : B
C |- e : A C, x: ∀X.A |- e’ : B
where X is the set of type variables free in A butnot in C: X = FV(A) - FV(C).
Constraint: all polymorphic types are prenex. (so cannot type (fn x => x x))
![Page 94: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/94.jpg)
26/7/00 Marktoberdorf 94
Polymorphic instantiation
• polymorphic types are implicitly instantiated
C |- x : [B/t]A
C |- x: ∀t.A
choose B cannonically by solving equationalconstraints during type inference
![Page 95: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/95.jpg)
26/7/00 Marktoberdorf 95
Principal typing
Given a term e and context C, if e has a typing wrt C, then there is a most general typing
C |- e : A
such that any typing of e in C is an instance:C |- e : A’ ⇒
A’ is a substitution instance of A.
![Page 96: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/96.jpg)
26/7/00 Marktoberdorf 96
Type inference algorithm
Find the most general typing by:
1. solving for the most general unifier of the equational constraints from typing diagrams.
2. quantifying (∀) any remaining type variables.
![Page 97: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/97.jpg)
26/7/00 Marktoberdorf 97
Primary sources of polymorphism
• generic functions
• parametric datatype constructors
fn x => x : ’a -> ’a
fn (x,y) => x : ’a * ’b -> ’a
nil : ’a list:: : ’a * ’a list -> ’a list
![Page 98: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/98.jpg)
26/7/00 Marktoberdorf 98
Polymorphism and refs
let val r = ref (fn x => x) in r := not; !r(3)end
r : ∀t.((t->t) ref)r : (bool->bool) refr : (int->int) ref
Oops! The type system is unsound!
![Page 99: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/99.jpg)
26/7/00 Marktoberdorf 99
The value restriction
We fix the type system by restricting thelet rule. In
we only generalize the type of x to a polymorphic type if e is a value expression.A value expression is a constant, variable, or function expression*. Value expressions represent final values, not computations.
let val x = e in ... end
![Page 100: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/100.jpg)
26/7/00 Marktoberdorf 100
System F (Fω )
• polymorphism with explicit type abstraction and type application
• polymorphism with variables of higher kinds (e.g. abstraction over type operators)
• nested, nonprenex polymorphic types• no value restriction needed for refs
![Page 101: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/101.jpg)
26/7/00 Marktoberdorf 101
Map in ML and System F
datatype ’a list = nil | :: of ’a * ’a list
fun map f nil = nil | map f (x::xs) = f x :: map f xsval map : (’a -> ’b) -> ’a list -> ’b list
List = Fun(s)µt.(Unit + s * t) (+null, hd,...)
map = Fun(s)Fun(t)fun(f:s->t)fun(xs:List s) if null[s]xs then nil[t] else
cons[t](f(hd[s]xs)) (map[s][t]f(tl[s]xs)) : All(s)All(t)(s->t) -> List s -> List t
![Page 102: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/102.jpg)
26/7/00 Marktoberdorf 102
Polymorphism and adaptation
• Polymorphic types defined an infinite family of instances, and (with H-M) the appropriate instance for any context is chosen automatically.
• The code for a polymorphic function is shared by all instances (parametricity).
![Page 103: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/103.jpg)
26/7/00 Marktoberdorf 103
Polymorphism and refs in System F
let r = ref[All(t)(t->t)](Fun(t)fun(x:t)x) in :=[Bool->Bool](r, not); (![All(t)(t->t)]r)[Int](3)end
(∀t.(t->t)) ref
type error!
![Page 104: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/104.jpg)
26/7/00 Marktoberdorf 104
Polymorphism and refs in System F
let r = Fun(t)ref[t->t](fun(x:t)x) in r[Bool] := not; (![Int->Int](r[Int])(3)end
All(t)((t->t)ref)
r[Bool]: Ref(Bool->Bool) andr[Int]: Ref(Int->Int)
are two different ref values!
![Page 105: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/105.jpg)
26/7/00 Marktoberdorf 105
IV. Modules
![Page 106: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/106.jpg)
26/7/00 Marktoberdorf 106
Generalizing polymorphism
Example: polymorphic sort
sort = Fun(t)fun(less: t*t->bool). ...
In this case, we need to parameterize over atype and an associated comparison function ina coordinated manner.
![Page 107: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/107.jpg)
26/7/00 Marktoberdorf 107
Generalizing polymorphism
Can we package the type and associated operation together and pass them as one parameter?
What are these hybrid parameter packages?
Modules!
sort = Fun(<t,less: t*t->bool>). ...
![Page 108: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/108.jpg)
26/7/00 Marktoberdorf 108
Basic Modules in ML
• A module is a package of (related) declarations (called a structure).
struct decl1 ... declnend
The component declarations can definetypes, values (e.g. data, functions, exceptions)and nested modules.
![Page 109: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/109.jpg)
26/7/00 Marktoberdorf 109
Structure declarations
Structures can be named in structure declarations.
The components of the named structure can be accessed using the dot notation:
structure A = struct ... end
A.t -- a typeA.f -- a functionA.B -- a substructure (nested module)A.B.x -- a value in A.B
![Page 110: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/110.jpg)
26/7/00 Marktoberdorf 110
Example: A stack structure
structure Stack =struct type ’a stack = ’a list exception Empty val empty : ’a stack = nil fun push(x,s) = x::s fun pop nil = raise Empty | pop(_::xs) = xs fun top nil = raise Empty | top(x::_) = xend
![Page 111: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/111.jpg)
26/7/00 Marktoberdorf 111
Example: using the Stack structure
val s0 : int Stack.stack = Stack.empty
val s1 = Stack.push(1,Stack.push(2,s0))
val s2 = Stack.pop s1
val x = Stack.top s2 handle Empty => 0
![Page 112: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/112.jpg)
26/7/00 Marktoberdorf 112
Signatures (interfaces)
• A signature is a type for a structure.– It defines the exported interface.– Each exported component has a type
specification.– A signature is implemented by any structure
that matches it.
![Page 113: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/113.jpg)
26/7/00 Marktoberdorf 113
The STACK signature
signature STACK =sig type ’a stack exception Empty val empty : ’a stack val push : ’a * ’a stack -> ’a stack val pop : ’a stack -> ’a stack val top : ’a stack -> ’aend
![Page 114: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/114.jpg)
26/7/00 Marktoberdorf 114
Signature constraints
We can (and usually do) specify a signature when declaring a structure.
structure Stack : STACK = struct ... end
Then we say that Stack is an instance of signature STACK.
![Page 115: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/115.jpg)
26/7/00 Marktoberdorf 115
Signature/Structure Independence
• Signatures and structures can be defined independently and later matched.
• Any signature can be matched by multiple structures (i.e. have multiple implementations)
• Any structure can match multiple signatures (i.e. can implement different interfaces, or be viewed through different interfaces)
![Page 116: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/116.jpg)
26/7/00 Marktoberdorf 116
Signature matching: thining
• Components of a structure can be hidden.• Component types can be specialized.• Signature matching is coercive.
structure A : sig type t val f : int -> t
end =struct type t = int val a = 3 (* not exported by A *) fun f x = a (* f: ’a -> t *)end
![Page 117: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/117.jpg)
26/7/00 Marktoberdorf 117
Signatures and record types
There is an analogy between signature matching and width subtyping for records.
Say SIG1 <: SIG2 if for any structure S, S:SIG1 implies S:SIG2 (i.e. any structure that matches SIG1 will also match SIG2).
![Page 118: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/118.jpg)
26/7/00 Marktoberdorf 118
Width subtyping of signatures
As for records, we can ignore extraneous elements.
sig type t type s val a: t val b: s*tend
sig type t val a: tend
<:
![Page 119: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/119.jpg)
26/7/00 Marktoberdorf 119
Depth subtyping of signatures
There is a simple analog of depth subtyping.sig val f: ’a -> intend
<:sig val f: int -> intend
because (’a -> int) <: (int -> int)
![Page 120: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/120.jpg)
26/7/00 Marktoberdorf 120
Transparent signature matching
exported types are not abstract (by default)
structure Stack : STACK =struct type ’a stack = ’a list ... end
(* Stack.stack == list *)
null(Stack.empty) : bool ==> true
![Page 121: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/121.jpg)
26/7/00 Marktoberdorf 121
Opaque signature matching
Can specify opaque matching, making exported types opaque.
structure Stack :> STACK =struct type ’a stack = ’a list ... end
(* Stack.stack =/= list *)
null(Stack.empty) (* type error *)
![Page 122: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/122.jpg)
26/7/00 Marktoberdorf 122
Sorting again
signature ORD = sig type elem val less : elem * elem -> boolend
structure IntOrd : ORD = struct type elem = int val less = (< : int * int -> bool)end
Note that IntOrd :> ORD would not be useful!
![Page 123: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/123.jpg)
26/7/00 Marktoberdorf 123
SORT signature
signature SORT =sig structure Ord : ORD val sort : Ord.elem list -> Ord.elem listend
![Page 124: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/124.jpg)
26/7/00 Marktoberdorf 124
A Sort structure
structure InsertSort : SORT =struct structure Ord : ORD = IntOrd fun insert(x,nil) = x::nil | insert(x,y::ys) =
if Ord.less(x,y) then x::y::ys else y::insert(x,ys)
fun sort nil = nil | sort (x::xs) = insert(x,sort xs)end
Fine, but it only sorts int lists.
![Page 125: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/125.jpg)
26/7/00 Marktoberdorf 125
Import by mention
• A structure definition imports other structures by mentioning them (i.e. having their names appear free in the body).
• E.g. IntOrd is imported by InsertSort.
![Page 126: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/126.jpg)
26/7/00 Marktoberdorf 126
A Generic Sort
functor InsertSortF(X: ORD) : SORT =struct structure Ord : ORD = X fun insert(x,nil) = x::nil | insert(x,y::ys) =
if Ord.less(x,y) then x::y::ys else y::insert(x,ys)
fun sort nil = nil | sort (x::xs) = insert(x,sort xs)end
Replace IntOrd with a parameter structurevariable X.
![Page 127: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/127.jpg)
26/7/00 Marktoberdorf 127
Instantiation of generic sort
A functor is a structure parameterized over astructure name. It can be instantiated byapplying the functor to a structure.
structure IntInsertSort : SORT = InsertSortF(IntOrd)
structure StringInsertSort : SORT = InsertSortF(StringOrd)
IntInsertSort.sort [4,7,1,3];StringInsertSort.sort [“bob”, “alice”];
![Page 128: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/128.jpg)
26/7/00 Marktoberdorf 128
Multiple implementations of sort
Other sorting methods can be provided byother functors that can be applied to IntOrd,StringOrd.
structure IntBubbleSort : SORT = BubbleSortF(IntOrd)
structure StringBubbleSort : SORT = BubbleSortF(StringOrd)
IntBubbleSort.sort [4,7,1,3];StringBubbleSort.sort [“bob”, “alice”];
![Page 129: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/129.jpg)
26/7/00 Marktoberdorf 129
Higher-order Functors
One can imagine abstracting a larger modulewith respect to the generic sort functor(InsertSortF, BubbleSortF, etc.).
functor Prog(SortF: GENSORT) = struct structure IntSort = SortF(IntOrd) structure StringSort = SortF(StringOrd) ...end
funsig GENSORT(X: ORD) = SORT where Ord = X
![Page 130: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/130.jpg)
26/7/00 Marktoberdorf 130
Fully Functorized Style
Suppose we have the following dependency graph
A
B
C
structure A = struct ... end
structure B = struct ... A ... end
structure C = struct ... A ... B ... end
![Page 131: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/131.jpg)
26/7/00 Marktoberdorf 131
Fully Functorized Style
Build the graph through functors, importing viaparameters.
functor MkA() = struct ... endfunctor MkB(A:SIGA) = struct ... A ... endfunctor MkC(A:SIGA,B:SIGB) = struct ... A ... B ...end
structure A = MkA()structure B = MkB(B)structure C = MkC(A,B)(* or *)structure C = MkC(A,MkB(A))
![Page 132: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/132.jpg)
26/7/00 Marktoberdorf 132
Translation of functors in Fω
functor F(X:sig type t val f: t*t->t end) : sig type u val g: X.t*u->u end =struct type u = t list fun g(x:t,y:u) = map (fn z => f(z,x)) yend
![Page 133: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/133.jpg)
26/7/00 Marktoberdorf 133
Translation of functors in Fω
Ft : Type -> Type = Fun(t:Type)(List t)
Fv : All(t:Type){f:t*t->t} -> {g:t*Ft(t)->Ft(t)} = Fun(t:Type)fun({f=f}:{f:t*t->t})
{g=(fun(x:t,y:Ft(t)) (map[t][Ft(t)](fun(z:t)f(z,x)) y}
F is translated into a pair <Ft, Fv> consisting ofa type function and a value function.
![Page 134: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/134.jpg)
26/7/00 Marktoberdorf 134
Things left out
• transparent and opaque signature matching
• sharing constraints and definitional specs
• higher-order functors
![Page 135: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/135.jpg)
26/7/00 Marktoberdorf 135
Exercise:
• Construct a similar example of a higher-order functor (e.g. a functor that would take F as a parameter) and give its Fω translation.
• Consider the problem of writing a functor signature that faithfully captures the type function part of your higher-order functor.
![Page 136: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/136.jpg)
26/7/00 Marktoberdorf 136
V. Object-Oriented Programming
![Page 137: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/137.jpg)
26/7/00 Marktoberdorf 137
Essence of Object-Oriented Programming• encapsulation of state• “dynamic dispatch”
– Type does not statically determine code run by a method invocation
– Standard situation in a higher-order language with interface types
• subtyping (or some approximation)• implementation sharing and modification
– class-based: inheritance– object-based: cloning with extension and
update
![Page 138: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/138.jpg)
26/7/00 Marktoberdorf 138
Degrees of OO purity
• OO as additional features for managing state and allocation on top of a conventional procedural language.– E.g.: Simula, C++, Object Pascal, Modula 3, ...
• OO (typically class-based) as the principle means of structuring programs
• pure or pervasive OO– everything is an object– classes as only program structuring method– E.g.: Smalltalk, Java (sort of)
![Page 139: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/139.jpg)
26/7/00 Marktoberdorf 139
Objects
What is an object?• state (in the form of instance variables)
• methods (functions acting on the state)
How does this differ from records of
function closures?
![Page 140: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/140.jpg)
26/7/00 Marktoberdorf 140
Object creation
• class-based languages– classes
• object based– direct creation– cloning from a prototype object
• with extension, method update• implemented via embedding or delegation
![Page 141: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/141.jpg)
26/7/00 Marktoberdorf 141
The magic of objects
capacity for incremental change offunctionality• in the objects themselves (method update)
• as part of object cloning• in the object generating mechanism
(subclassing)
![Page 142: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/142.jpg)
26/7/00 Marktoberdorf 142
Classes
What is a class?
• specifies data representation (instance variables)
• specifies implementation of methods• specifies how objects are initialized• specifies inheritance from superclass(es)
a template used to generate objectsgenerated objects are “instances” of the class
![Page 143: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/143.jpg)
26/7/00 Marktoberdorf 143
Deconstructing objects and classes
Goal: To explain away the magic of OO.
Approach: Try to code objects and classes in a richly
typed functional programming language: Fω + <: + Rec + Ref + with + ...
![Page 144: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/144.jpg)
26/7/00 Marktoberdorf 144
Existential Types
A ::= ... | Some(t)A
e ::= ... | pack t = A with e | open e as (t,x) in e’
C |- pack t = A with e : Some(t)B
C; t=A |- e : B
C |- e : Some(t)A
C |- open e as (t,x) in e’ : B
C; t:Type; x:A |- e’: B
![Page 145: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/145.jpg)
26/7/00 Marktoberdorf 145
Type models for OO languages
Existential type (Pierce, Turner)Some(t)I(t)
Recursive-Existential types (Bruce)Rec(t)Some(u)(u * (u -> I(t)))
Recursive-Bounded-Existential (Abadi, Cardelli, Vis.)Rec(t)Some(u<:t)(u * (u -> I(t)))
Recursive record (Cardelli, Cook, Mitchell)Rec(t)I(t)
![Page 146: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/146.jpg)
26/7/00 Marktoberdorf 146
1. object as record of functions
Cell object is modeled as a record of variables and functions:
{x = ref 0, get = fun()!x, set = fun(y:Int)(x:=y)}: {x: Ref Int, get: Unit->Int, set: Int->Unit}
Bogus: x is free in bodies of get, set.
![Page 147: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/147.jpg)
26/7/00 Marktoberdorf 147
Cell: private variable x
We could make the variable x private:
But this would make it impossible to extend the record with new functions that have access to x.
let x = ref 0 in {get = fun()!x, set = fun(y:Int)(x:=y)}: {get: Unit->Int, set: Int->Unit}
![Page 148: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/148.jpg)
26/7/00 Marktoberdorf 148
2. Adding self-reference
give a name for the object to refer to itself (making it a recursive record)
self = {x = ref 0, get = fun()!self.x, set = fun(y:Int)(self.x:=y)}
self = Fix(fun(self) {x = ref 0, get = fun()!self.x, set = fun(y:Int)(self.x:=y)})
![Page 149: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/149.jpg)
26/7/00 Marktoberdorf 149
3. Naming the generator function
Give a name to the fixpoint generating function (essentially a class!)
CI = {x: Ref Int, get: Unit->Int, set: Int->Unit}
Cell = fun(self: CI) {x = ref 0, get = fun()!self.x, set = fun(y:Int)(self.x:=y)} : CI -> CI
c = new Cell = Fix(Cell) = µself.Cell(self)
![Page 150: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/150.jpg)
26/7/00 Marktoberdorf 150
4. Variable initialization
add initialization of the x variable
Cell = fun(n: Int)fun(self: CI) {x = ref n, get = fun()!self.x, set = fun(y:Int)(self.x:=y)} : Int -> CI -> CI
c = new (Cell 3)
Easy so far -- using value recursion todirectly build the object.
![Page 151: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/151.jpg)
26/7/00 Marktoberdorf 151
5. Inheritance: adding a method
Inheritance: easy case of adding a method
CI2 = CI + {inc: Unit -> Unit}
Cell2 : Int -> CI2 -> CI2 = fun(n: Int)fun(self: CI2) Cell(n)(self) with
{inc = fun()(self.x := !self.x+1)}
Note: Cell(n)self is well-typed becauseCI2 <: CI.
![Page 152: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/152.jpg)
26/7/00 Marktoberdorf 152
6. Record concatenation
We are using record concatenation to add the inc method.{a: Int, b: Bool} + {b: Real, c: String} = {a: Int, b: Real, c: String}
{a=3, b=true} with {b=1.7, c=“cat”} = {a=3, b=1.7, c=“cat”}
Usual rule for map concatenation.
![Page 153: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/153.jpg)
26/7/00 Marktoberdorf 153
Record concatenation problem
Oops!!e1: {a: Int}e2: {a: Bool, b: Int}
e1 with e2: {a: Bool, b: Int}
e1: {a: Int}e2: {b: Int}
e1 with e2: {a: Int, b: Int}
but {a: Bool, b: Int} <: {b: Int}implies e2: {b: Int}, so we also have
![Page 154: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/154.jpg)
26/7/00 Marktoberdorf 154
Record concatenation and subtyping
This example shows that with record concatenation and record subtyping, we can derive two incompatible typings of e1 with e2 .
The reason? with is an operation on records where extra fields make a difference.
![Page 155: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/155.jpg)
26/7/00 Marktoberdorf 155
Exercise
Suggest a fix that will allow record concatenation and width record subtypine to coexist.
![Page 156: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/156.jpg)
26/7/00 Marktoberdorf 156
8. Recursive interface type
We need to add recursive interface types.Cell = fun(n: Int)fun(self: CI) {x = ref 0, get = fun()!self.x, set = fun(y:Int)(self.x:=y),
me = fun()self} : Int -> CI -> CI
whereCI = {x: Ref Int, get: Unit->Int, set: Int -> Unit,
me: Unit -> CI}
![Page 157: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/157.jpg)
26/7/00 Marktoberdorf 157
Recursive Interface Type
CI = µt.{x: Ref Int, get: Unit -> Int, set: Int -> Unit,
me: Unit -> t} = Fix(CIF)
whereCIF = Fun(t){x: Ref Int, get: Unit -> Int, set: Int -> Unit,
me: Unit -> t}
![Page 158: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/158.jpg)
26/7/00 Marktoberdorf 158
9. Inheritance with recursive interface
Add inc method to cell with me method.
Cell2 : Int -> CI2 -> CI2 = fun(n: Int)fun(self: CI2) Cell(n)(self) with
{inc = fun()(self.x := !self.x+1)}
![Page 159: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/159.jpg)
26/7/00 Marktoberdorf 159
Extending recursive interface
There are two ways to extend the recursive interface type CI: outside the recursion, or inside.
CI2 = CI + {inc: Unit -> Unit} = {x: Ref Int, get: -, set: -,
me: Unit -> CI, inc: Unit -> Unit}
CI2’= µt.(CIF(t) + {inc: Unit -> Unit}) = {x: Ref Int, get: -, set: -,
me: Unit -> CI2’, inc: Unit -> Unit}
![Page 160: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/160.jpg)
26/7/00 Marktoberdorf 160
Extending recursive interface
CI2 <: CI because of record (width) subtyping
CI2’ <: CI
because of the recursion rule (CI2’ appearsin a positive, covariant position)
![Page 161: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/161.jpg)
26/7/00 Marktoberdorf 161
10. Method not specialized
Cell(n) : CI -> CI
=> Cell(n)self : CI (self: CI2 <: CI)
=> body of Cell2 : CI + {inc: Unit -> Unit}
=> Cell2: CI2 -> CI2
=> me method: Unit -> CI (not CI2)
Oops! In CI2, the type of the me methodwasn’t specialized.
![Page 162: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/162.jpg)
26/7/00 Marktoberdorf 162
Class Functions, Class Interface
Class A :
A = fun(<init>)fun(self: AI) <record expression> : InitTyA -> AI -> AI
AIF = Fun(t)<record type>
AI = Fix(AIF)
a = Fix(A x0)
![Page 163: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/163.jpg)
26/7/00 Marktoberdorf 163
Inheritance by deriving class function
Class B inherits from A :
B = fun(<init>)fun(self: BI) A(<init’>(self) with <record expression> : InitTyB -> BI -> BI
BIF = Fun(t)(AIF(t) + <record type>)
BI = Fix(BIF)
b = Fix(B x1)
![Page 164: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/164.jpg)
26/7/00 Marktoberdorf 164
11. Method specialization
To get
Cell2: CI2’ -> CI2’
with the type of me specialized to return’ CI2’, we need to generalize the type of Cell (so it doesn’t return CI).We make Cell polymorphic, but with a new twist: bounded polymorphism.
![Page 165: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/165.jpg)
26/7/00 Marktoberdorf 165
Method specialization
Cell = Fun(t<:CI)fun(n:Int)fun(self:t) {x: ref n, get = ...,
me = fun()self}
Cell: All(t<:CI)Int -> t -> CIF(t)
We need t<:CI so that self.x type checks.
c : CI = new (Cell[CI] 3)
Cell[CI] : Int -> CI -> CIF(CI) = Int -> CI -> CI
![Page 166: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/166.jpg)
26/7/00 Marktoberdorf 166
Bounded quantification
Fun(t<:A) and All(t<:A)are bounded type abstraction and quantification where the type variable t is constrained to range over subtypes of A.
This guarantees that t has certain properties, e.g. is a record type with certain fields (assuming that a subtype of a record is a record ...).
![Page 167: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/167.jpg)
26/7/00 Marktoberdorf 167
Method specializationCell2 = Fun(t<:CI2’)fun(n:Int)fun(self:t)
Cell[t](n)(self) with {inc = fun()(self.x := !self.x+1)}
Cell2: All(t<:CI2’)Int -> t -> CIF2(t)whereCIF2 = Fun(t)(CIF(t)+{inc: Unit -> Unit})CI2’ = Fix(CIF2)
Note that CI2’<:CI, so t<:CI2’ => t <: CI.
c: CI2’ = new (Cell2[CI2’] 3)
![Page 168: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/168.jpg)
26/7/00 Marktoberdorf 168
13. Binary methods
Start over, but with Cell having a binary method eq.
CIF = Fun(t){x: Ref Int, get: -, set: -, eq: t -> Bool}
CI = Fix(CIF)
Cell = fun(n: Int)fun(self: CI) {x = ref n, get = -, set = -,
eq = fun(y:CI)(!self.x = !y.x)}
Cell: Int -> CI -> CI
![Page 169: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/169.jpg)
26/7/00 Marktoberdorf 169
14. Inheritance with Binary Methods
Add a boolean field and override eq to check bool field.CI2 = CI + {b: Ref Bool, eq: CI2 -> bool}
Cell2 = fun(n: Int)fun(Self: CI2) Cell(n)(self) with
{b = ref true, eq = fun(c:CI2)(!self.x = !c.x and !self.b = !c.b)}
Oops! CI2 </: CI because of the contravariantchange in eq’s type. Type error!
![Page 170: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/170.jpg)
26/7/00 Marktoberdorf 170
Inheritance with binary methods
How about
CI2’ = µt.(CIF(t) + {b: Ref Bool}) ?
Again CI2’ </: CI because of thecontravariant occurrence of t. AgainCell(n)(self) won’t type check.
Bounded quantifier trick won’t help here becauseCI2’ </: CI.
![Page 171: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/171.jpg)
26/7/00 Marktoberdorf 171
F-bounded polymorphism
Cell = Fun(t<:CIF(t))fun(n:Int)fun(self:t) {x = ref n, get = -, set = -,
eq = fun(c:t)(!self.x = !c.x)}Cell: All(t<:CIF(t))(Int -> t -> CIF(t))
CIF2 = Fun(t).(CIF(t)+{b: Ref Bool})
Cell2 = Fun(t<:CIF2(t))fun(n:Int)fun(self:t) Cell[t](n)(self) with
{b = ref true, eq = fun(c:t)(!self.x = !c.x and !self.b = !c.b)}
Cell2: All(t<:CIF2(t))Int -> t -> CIF2(t)
![Page 172: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/172.jpg)
26/7/00 Marktoberdorf 172
Inheritance without subtyping
Cell[t](n)(self) type checks because
t <: CIF2(t) = CIF(t) + {b: Ref Bool} => t <: CIF(t)
c2 : CI2 = new (Cell2[CI2] 3)where CI2 = Rec(CIF2)
CI2 = Fix(CIF2) </: Fix(CIF) = CI
so inheritance does not imply subtypes, but
CI2 <: CIF(CI2)
![Page 173: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/173.jpg)
26/7/00 Marktoberdorf 173
Object protocols
Constraints liket <: F(t) (1)
are called object protocols. An object type satisfying such a protocol is recursive and provides the interface specified by F (wrt to itself).A t satisfying (1) is not necessarily a subtype ofut.F(t), so (1) is a weaker constraint thant <: ut.F(t) (2)
![Page 174: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/174.jpg)
26/7/00 Marktoberdorf 174
16. Class recursion
Suppose we want a method that returns a new object of the same kind.
Cell = Fun(t<:CIF(t))fun(n:Int)fun(self:t) {x = -, get = -, set = -,
double = fun()new(Cell[CI](2*!self.x))}
CIF = Fun(t){x: Ref Int,...,double: Unit->t}
CI = Fix(CIF)
![Page 175: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/175.jpg)
26/7/00 Marktoberdorf 175
Class recursion
Cell is called recursively, so we create afunctional to take the fixpoint of:
CELL = Fun(t<:CIF(t)) fun(myclass: Int -> t ->t) fun(n: Int)
fun(self: t){x = ..., double =
fun()new(myclass(2*!self.x))}
CELL: All(t<:CIF(t))(Int -> t -> t)-> (Int -> t -> CIF(t))Cell = Fix(CELL[CI])c = new(Cell 3)
![Page 176: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/176.jpg)
26/7/00 Marktoberdorf 176
Inheritance with Class Recursion
CELL2 = Fun(t<:CIF2(t)) fun(myclass: Int*Bool -> t -> t) fun(n:Int,b:Bool) fun(self:t) (CELL[t]
(fun(x:Int)(myclass(x,self.b))) (n)(self)) + {b = b}
Add a new boolean field to Cell.CIF2 = Fun(t)(CIF(t) + {b: Bool})
![Page 177: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/177.jpg)
26/7/00 Marktoberdorf 177
Observations
• Three levels of recursion:– in the construction of objects– in the construction of object types– in the construction of classes
• Bounded polymorphism for covariant method specialization
• F-bounded polymorphism for contravariant method specialization
The recursive record coding becomes convoluted.
![Page 178: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/178.jpg)
26/7/00 Marktoberdorf 178
Observations
• Contravariance causes complications
– Inheritance and subtyping are uncoupled: Subclass interface is not a subtype of the superclass interface.
– The F-bounded relation (“matching”) replaces subtyping.
![Page 179: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/179.jpg)
26/7/00 Marktoberdorf 179
Technical Problems
• Recursive definitions of mixed records of fields and methods– more refined models separate fields and
methods
• Coexistence of record (width) subtyping and record concatenation
![Page 180: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/180.jpg)
26/7/00 Marktoberdorf 180
Features Explained
• objects• object (interface) types• classes• new• inheritance• covariant method specialization• contravariant method specialization (binary
methods)• MyType (the type variable in polymorphic class
functions)
![Page 181: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/181.jpg)
26/7/00 Marktoberdorf 181
Features Not Explained
• super• private, protected members• object cloning• multiple constructors• class (static) members• nested (static) classes• inner classes• anonymous classes• multiple inheritance
![Page 182: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/182.jpg)
26/7/00 Marktoberdorf 182
OO issues
• implementation inheritance and open recursion• interface types vs implementation (class) types• inheritance vs subtyping• method specialization• contravariance: binary method problem• invariance of mutable variables• access control features and scope dependent
types• methodologincal problems of OO
![Page 183: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/183.jpg)
26/7/00 Marktoberdorf 183
Method recursion
• methods can call one another, hence are mutually recursive
• recursion of methods is typically indirect, via a self variable, to facilitate open recursion
![Page 184: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/184.jpg)
26/7/00 Marktoberdorf 184
Open Recursion
• Methods are mutually recursive ⇒ incremental change may involve open recursion.
• Some methods change, while others remain the same. But since they are mutually recursive, the behavior of any or all methods may change.
• Extension with new methods does not involve open recursion, because old methods will not call the new ones.
![Page 185: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/185.jpg)
26/7/00 Marktoberdorf 185
Open Recursion Example
O1 = {x = fun()1, y = fun()(2*self.x())}O2 = {x = fun()1, y = fun()2 }
O1’ = O1 + {x = fun()2}O2’ = O2 + {x = fun()2}
O1’.x() ==> 2 O1’.y() ==> 4O2’.x() ==> 2 O2’.y() ==> 2
O1.x() ==> 1 O1.y() ==> 2O2.x() ==> 1 O2.y() ==> 2
![Page 186: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/186.jpg)
26/7/00 Marktoberdorf 186
Classes as types
• in most class-based languages, a class is a type, and subclasses are subtypes
• object has a class type if it is an instance of that class or one of its subclasses
• class types determine an interface: a set of publicly accessible attributes and their types
• class types have a family of associated implementations: the class and all its subclasses
![Page 187: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/187.jpg)
26/7/00 Marktoberdorf 187
Classes as types (cont.)
• An object may have a class type without sharing any of the implementation of that class. Being a member of a class type does not guarantee any consistency of behavior.
• Class types usually support some form of dynamic typecase.– checked casts– classOf operations to query the class of an
object
![Page 188: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/188.jpg)
26/7/00 Marktoberdorf 188
Interface types vs Class Types
1. Can’t dynamically ask if an objecthas an interface type
2. Consequently, can’t do checked typecasts to an interface type
3. Interface types do not determine animplementation
4. In binary methods the two objects mayhave different implementations.
![Page 189: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/189.jpg)
26/7/00 Marktoberdorf 189
Classes and abstract types• OO folklore: class = abstract type• abstract types determine:
– a fixed, hidden data representation– a fixed interface of operations– a fixed implementation that guarantees
invariants and other desired properties
• belonging to a class (as type) does not guarantee consistent implementation, because of method override
• only “final” classes are “abstract”
![Page 190: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/190.jpg)
26/7/00 Marktoberdorf 190
Classes vs modules• “static” (or “class”) variables and methods
and (in Java) static embedded classes allow classes to act as a limited form of module
• lack independently defined module interfaces
• the class mechanism is overloaded to perform the role of modules. The function of modules is better performed by simpler, special purpose constructs (see Moby and Loom designs)
![Page 191: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/191.jpg)
26/7/00 Marktoberdorf 191
Method specialization
• Method specialization with covariant occurrences of the object type is easy– C++ allows this, Java requires invariant method
types
• Method specialization with contravariant occurrences of the object type (binary methods) is possible,– but subtyping is weakened to “matching” an
object protocol
![Page 192: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/192.jpg)
26/7/00 Marktoberdorf 192
Partially abstract object types
Subtype specs like
t <: CI
or object protocol specs like
t <: CIF(t)
can be used to partially reveal the interface ofobjects or limit access to object attributes
![Page 193: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/193.jpg)
26/7/00 Marktoberdorf 193
VI. Comparing FP and OO
![Page 194: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/194.jpg)
26/7/00 Marktoberdorf 194
Factoring behavior
• FP– fully specify the data (all variants)– incrementally add functions over the data– adding new variants to data requires
rewriting functions
• OO– incrementally specify the data variants by
adding subclasses– adding new functions requires adding new
methods to all subclasses
![Page 195: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/195.jpg)
26/7/00 Marktoberdorf 195
FP: modifying behavior
• have to anticipate what factors will change and abstract over appropriate names
• can’t change parameterization of existing code without rewriting the code
• get maximal flexibility by parameterizing over everything, but this is usually inconvenient
FP relies almost entirely on parameterization
![Page 196: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/196.jpg)
26/7/00 Marktoberdorf 196
OO: modifying behavior
• effectively same as modifying the class source
• claim that this accommodates “unanticipated” changes
• code change requires thorough understanding of old code to determine what behavior changes, what behavior is preserved
inheritance with method override
![Page 197: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/197.jpg)
26/7/00 Marktoberdorf 197
“Binary” functions
• OO– hard to implement symmetric functions
(binary methods)– hard to dispatch over multiple arguments
• FP– easy to define symmetric functions and
dispatch over multiple arguments
![Page 198: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/198.jpg)
26/7/00 Marktoberdorf 198
Types in FP
• all types are interface types except abstract types
• abstract types carry a fixed interface implementation
![Page 199: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/199.jpg)
26/7/00 Marktoberdorf 199
Types in OO• interface types
– allow multiple implementations• implementations may match any interface type, or • implementations must declare what interface types
they match
• implementation types (class types)
– final classes fix the implementation, can be considered a kind of abstract type
– other classes allow a family of implementations represented by their subclasses (multiple implementations related by subclassing)
![Page 200: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/200.jpg)
26/7/00 Marktoberdorf 200
Synthesizing FP and OO
![Page 201: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/201.jpg)
26/7/00 Marktoberdorf 201
Why?
• clear utility of subtyping (OO)• clear utility of parametric polymorphism• state encapsulation ?• implementation inheritance ?• popularity of OO
![Page 202: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/202.jpg)
26/7/00 Marktoberdorf 202
Merging FP and OO
• Pizza (Wadler & Oderski)– added encodings of functions, datatypes, and
parametric polymorphism to Java
• GJ - Generic Java (Wadler, Oderski, ...)– add parametric polymorphism and F-bounded
polymorphism to Java
![Page 203: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/203.jpg)
26/7/00 Marktoberdorf 203
Encoding objects in ML
Tofte and Thorup showed how the existential type model could be coded in Standard ML,using explicit coercions in place of subtyping.
The encoding machinery is heavy, but some simple type system extensions and syntactic sugar could might make this encoding useable.
![Page 204: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/204.jpg)
26/7/00 Marktoberdorf 204
OCaml (Objective Caml)
• adds objects, object types, classes to Caml dialect of ML
• based on Pierce-Turner existential model• uses “row” polymorphism in place of record
subtyping:
• explicit coercion rather than subsumption• classes not first class, limited interaction
with modules
∀ρ.{a: int, b: bool, ρ} -> int
![Page 205: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/205.jpg)
26/7/00 Marktoberdorf 205
Moby (Fisher and Reppy)
• subtypes, nested parametric polymorphism• object types and classes, based on Fisher’s
“protocol” model• object view and class view• uses modules for visibility control• many Java features
![Page 206: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/206.jpg)
26/7/00 Marktoberdorf 206
F<,rec• provides
– subtyping– parametric polymorphism at all kinds– nested polymorphism– bounded polymorphism (but not F-bounded)– records– existential types, bounded existential types– can express most OO encodings
• problems– cumbersome explicit typing, practical type
inference algorithms not proven
![Page 207: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/207.jpg)
26/7/00 Marktoberdorf 207
Extended ML
• encapsulated existential and universal types
• extensible datatypes (incrementally add data constructors)
• row-polymorphism for record types or limited record subtyping
Simple extensions of the ML type system canimprove ability to emulate OO techniques
![Page 208: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/208.jpg)
26/7/00 Marktoberdorf 208
Final Thoughts
![Page 209: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/209.jpg)
26/7/00 Marktoberdorf 209
FP vs OO
• FP has simpler, lighter-weight structures– functions vs objects– records, datatypes vs objects– polymorphism, modules vs subtyping, inheritance
• Both OO and FP can encapsulate state• Subtyping would be a valuable addition to FP,
but type inference must be dealt with• Inheritance is probably not worth adding to
FP.
![Page 210: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/210.jpg)
26/7/00 Marktoberdorf 210
Language Complexity budget
• Adding a full-featured object/class system to a language like ML will roughly double the complexity of the type system.
• The OO features are relevant only to the impure 5-10% of typical ML programs.
• This appears to be a bad bargain.
![Page 211: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/211.jpg)
26/7/00 Marktoberdorf 211
Language design criticism
Should the study of language designs be like botany or horticulture?
![Page 212: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/212.jpg)
26/7/00 Marktoberdorf 212
Type Theory
Type theory is an excellent tool forlanguage design and the analysis oflanguage designs.
![Page 213: Structure and Abstraction in HOT Languagespeople.cs.uchicago.edu/.../proglang/papers/Marktoberdorf.pdfStructure and Abstraction in HOT Languages A Comparison of Polymorphism, Modules,](https://reader034.fdocuments.in/reader034/viewer/2022042211/5eb1767c43ed331ca8486bf1/html5/thumbnails/213.jpg)
26/7/00 Marktoberdorf 213
URLs
http://www.smlnj.org
Standard ML and Standard ML of New Jersey