DOCSLIB.ORG

CS 411 Lecture 21 Introduction to Polymorphism & Subtyping 24 Oct

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
CS 411 Lecture 21 Introduction to Polymorphism & Subtyping 24 Oct CS 411 Lecture 21 Introduction to Polymorphism & Subtyping 24 Oct 2003 Lecturer: Greg Morrisett There are 3 basic kinds of polymorphism: • Subtyping (or inclusion) polymorphism. • Parametric polymorphism. • Ad hoc polymorphism. Subtyping arises when we can pass an object of type τ1 to an operation (including a function or method) that expects a τ2 and we don’t get a type-error. Most modern languages, including Java and C#, have some notion of subtyping as the basic form of polymorphism. Parametric polymorphism is a generalization of abstract data types and languages such as ML and Haskell are notable for their inclusion of parametric polymorphism. Parametric polymorphism arises naturally for functions, such as the identity, or list reversal, where we manipulate objects in a way that’s oblivious to the type. Unlike subtyping, it’s possible to express input-output relationships on type signatures which gives the caller more reasoning power. But, subtype polymorphism tends to work better (or at least more easily) for dealing with heterogeneous data structures. Note, however, that you can simulate subtyping in a pretty straightforward way with parametric polymor- phism, but it requires passing around coercion functions. You can also simulate parametric polymorphism in a language like Java, but it requires run-time type tests. So neither situation is ideal, and next-generation languages, including Java 1.5 and C# include a notion of “generics” which generalizes both subtyping and parametric polymorphism. Ad hoc polymoprhism is everything else. Overloading is a good example. Something like “+” appears to work on both integers and reals, but note that we get different code for the different operations. Furthermore, “+” is only defined on some types and there’s no way to abstract over those types. Languages such as C++ provide a lot of support for ad hoc polymorphism through templates, but anyone who has used template libraries can tell you that this was not well thought through. Language researchers, particularly in the Haskell camp, have been working on better ways to support the power of ad hoc polymorphism (sometimes called polytypism) and this, coupled with notions of reflection, are hot research topics. This is mostly because we don’t have a clean handle on these concepts the same way we do subtyping and parametric polymorphism. The funny thing is that it’s only in the last 15 years that we’ve gotten a good handle on those two! Subtyping This arises naturally if we think about the idea of “types as sets”, for then “subtypes are subsets”. More abstractly, the principle behind subtyping is that, if you can use a value of type τ1 anywhere that you expect to have a value of type τ2, then you ought to be able to treat τ1 as a subtype of τ2. For example, given record types: type point2d = {x:int, y:int} type point3d = {x:int, y:int, z:int} then we ought to be able to pass in a point3d to any function expecting a point2d, because all that function can do is select out the x or y components, and those operations are defined on point3d values as well as point2d values. 1 If we think of point2d and point3d as interfaces (`ala Java or C#) then it’s natural to think that anything that implements the point3d interface also implements the point2d interface. We can extend our little functional language with subtyping by adding one new rule called subsumption: Γ ` e : τ1 τ1 ≤ τ2 Γ ` e : τ2 The rule says that if e has type τ1 and τ1 is a subtype of τ2, then e also has type τ2. Of course, now we need to define what it means for one type to be a subtype of another. Remember the principle to follow is that τ1 ≤ τ2 means that for any operation op you can perform on a τ2 value, you should be able to perform op on a τ1 value. All subtyping frameworks yield a partial order so they include rules for reflexivity and transitivity: τ ≤ τ τ1 ≤ τ2 τ2 ≤ τ3 τ1 ≤ τ3 For something like (immutable) records, the subtyping rule might look like this: 0 0 τ1 ≤ τ1 . τn ≤ τn 0 0 {l1 : τ1, . , ln : τn, ln+1 τn+1} ≤ {l1 : τ1, . , ln : τn} 0 This rule says that a record type R1 is a subtype of a record type R2 if for all l : τ in R2, there exists a label 0 l with type τ in R1, and furthermore, τ ≤ τ . This rule is sound because the only operation we can apply to an R2 value is to extract a component using the #l operation. If #l is defined in R1, then the operation will succeed. And intuitively, if that yields a value of type τ, then we can use subtyping to show that τ ≤ τ 0. What about sums? Consider the datatypes: datatype t1 = C1 of int datatype t2 = C1 of int | C2 of bool datatype t3 = C1 of int | C2 of bool | C3 of real The only operation on sums is to do a case on them. If I have a case that can handle all of the constructors of t3, then it’s safe to pass in a t2 or a t1 value because the set of constructors in those types is a subset of the set used in the definition of t3. So, for sums, the subtyping rule is the opposite – the subtype must have fewer labels. 0 0 τ1 ≤ τ1 . τn ≤ τn 0 0 [l1 of τ1 | ... | ln of τn] ≤ [l1 of τ1 | ... | ln of τn | ln+1 of τn+1] 0 Notice also that we assume that τ1 ≤ τ1 instead of the other way around for records. So, once again, sums are pleasingly dual to products. What about functions? The only operation on a function is to apply it to some argument. So, suppose I have a function: f :({x : int, y : int} → {x : int, y : int}) → int Suppose that I have another function: g : {x : int} → {x : int, y : int, z : int} 2 Does it make sense to pass g to f? That is, what can go wrong if we do f(g)? Well, f might try to apply g to some argument. It thinks that g takes in {x : int, y : int} arguments. So, it might pass an {x : int, y : int} value to g. Now g thinks that it’s being given an argument of type {x : int}, so the only thing it can do is apply #x to the argument. That seems to be okay because conceptually, we can use subtyping to treat the {x : int, y : int} value as if it’s a {x : int} value. What about the result? f thinks that g returns {x : int, y : int} so it might do #x or #y on the result. But g returns a {x : int, y : int, z : int} value. Again, this is okay because the operations that f might do on g’s result are okay. Or conceptually, we can apply subtyping to coerce g’s result to {x : int, y : int} if you like. So it appears as if g’s type is a subtype of the argument type of f. That is, we have: ({x : int} → {x : int, y : int, z : int}) ≤ ({x : int, y : int} → {x : int, y : int}) In general, the subtyping rule for functions is: 0 0 τ1 ≤ τ1 τ2 ≤ τ2 0 0 (τ1 → τ2) ≤ (τ1 → τ2) So note that the argument types are contra-variant while the result types are co-variant. There are a lot of ways to see why contra-variance in the argument type is necessary. The example above demonstrates this, but so does drawing a Venn diagram of sets, subsets, and mappings from one set to another. Or from a logical standpoint, we can think of (τ1 → τ2) as similar to (¬τ1 ∨ τ2) — the negation on the argument suggests that we’ll have to flip the subtyping around. Subtypes as Subsets vs. Coercions Earlier, I said that we can think of subtypes as “subsets” and this is the general principle that most languages follow. However, it requires that we have a uniform representation for values that lie in related types. For instance, in Java, all Objects are one word so that we can pass them around, stick them in data structures, etc. But that means that double values are not Objects. A boxed double value (e.g., Double) is a subtype of Object, and we can coerce a double to a Double. So, in some sense, double is a “coerceable-subtype” of Object. In fact, we can think of all of the subtyping rules as being witnessed by some coercion function. In particular, if we think of τ1 ≤ τ2 as a function C : τ1 → τ2, then the subsumption rule becomes: Γ ` e : τ1 C : τ1 → τ2 Γ ` C e : τ2 The other coercions can be calculated as follows: λx : τ. x : τ → τ (reflexivity is the identity) C1 : τ1 → τ2 C2 : τ2 → τ3 (transitivity is composition) C1 ◦ C2 : τ3 Then record subtyping is witnessed by this coercion: 0 0 C1 : τ1 → τ1 ...Cn : τn → τn λr : {l1 : τ1, . , ln : τn, ln+1 : τn+1}. {l1 = C1(#l1 r), . , ln = Cn#ln } 3 Coercion-based subtyping is simpler from the perspective of the language designer and implementor, and it doesn’t require us to have uniform representations for objects. But coercions aren’t so attractive for the programmer. First, they cost time. Second, they don’t work for mutable objects since they fundamentally operate by making a copy of the object. (You can achieve this by providing a level of indirection.
Load more

Recommended publications
  • Unifying Nominal and Structural Ad-Hoc Polymorphism
    Unifying Nominal and Structural Ad-Hoc Polymorphism Stephanie Weirich University of Pennsylvania Joint work with Geoff Washburn Ad-hoc polymorphism Define operations that can be used for many types of data Different from Subtype polymorphism (Java) Parametric polymorphism (ML) Behavior of operation depends on the type of the data Example: polymorphic equality eq : ∀α. (α′α) → bool Call those operations polytypic Ad hoc polymorphism Appears in many different forms: Overloading Haskell type classes Instanceof/dynamic dispatch Run-time type analysis Generic/polytypic programming Many distinctions between these forms Compile-time vs. run-time resolution Types vs. type operators Nominal vs. structural Nominal style Poster child: overloading eq(x:int, y:int) = (x == y) eq(x:bool, y:bool) = if x then y else not(y) eq(x: α′β, y: α′β) = eq(x.1,y.1) && eq(x.2,y.2) Don’t have to cover all types type checker uses def to ensure that there is an appropriate instance for each call site. Can’t treat eq as first-class function. Structural style Use a “case” term to branch on the structure of types eq : ∀α. (α′α) → bool eq[α:T] = typecase α of int ) λ(x:int, y:int). (x == y) bool ) λ(x:bool,y:bool). if x then y else not(y) (β′γ) ) λ(x: β′γ, y: β′γ). eq[β](x.1,y.1) && eq[γ](x.2,y.2) (β → γ) ) error “Can’t compare functions” Nominal vs. Structural Nominal style is “open” Can have as many or as few branches as we wish.
    [Show full text]
  • POLYMORPHISM Today Polymorphism Coercion
    Today • We will finish off our discussion of inheritance by talking more about the way that inheritance enables polymorphism. • This will lead us into a few topics that we didn’t yet cover: – Operator overloading – The relationship between friendship and inheritance POLYMORPHISM • It will also preview the idea of templates which we will cover properly in the next unit. • The textbook says little about polymorphism explcitly (see pages 484-485) but does have a lot to say about the methods for achieving it in various places. • For example there is a long discussion of operator overloading on pages 243-263. cis15-spring2010-parsons-lectV.4 2 Polymorphism Coercion • The folk who know about these things have declared that C++ • Coercion is when we write code that forces type conversions. has four mechanisms that enable polymorphism: • It is a limited way to deal with different types in a uniform way. – Coercion • For example This is considered to be ad hoc polymorphism. – Overloading double x, d; Again, this is considered to be ad hoc. int i; x = d + i; – Inclusion This is pure polymorphism. • During the addition, the integer i is coerced into being a double – Parametric polymorphism so that it can be added to d. Again this is pure. • So you have been using polymorphism for ages without • We will look at each of these in turn in some detail. knowing it. cis15-spring2010-parsons-lectV.4 3 cis15-spring2010-parsons-lectV.4 4 Overloading • Overloading is the use of the same function or operator on different kinds of data to get different results.
    [Show full text]
  • Lecture Notes on Polymorphism
    Lecture Notes on Polymorphism 15-411: Compiler Design Frank Pfenning Lecture 24 November 14, 2013 1 Introduction Polymorphism in programming languages refers to the possibility that a function or data structure can accommodate data of different types. There are two principal forms of polymorphism: ad hoc polymorphism and parametric polymorphism. Ad hoc polymorphism allows a function to compute differently, based on the type of the argument. Parametric polymorphism means that a function behaves uniformly across the various types [Rey74]. In C0, the equality == and disequality != operators are ad hoc polymorphic: they can be applied to small types (int, bool, τ∗, τ[], and also char, which we don’t have in L4), and they behave differently at different types (32 bit vs 64 bit compar- isons). A common example from other languages are arithmetic operators so that e1 + e2 could be addition of integers or floating point numbers or even concate- nation of strings. Type checking should resolve the ambiguities and translate the expression to the correct internal form. The language extension of void∗ we discussed in Assignment 4 is a (somewhat borderline) example of parametric polymorphism, as long as we do not add a con- struct hastype(τ; e) or eqtype(e1; e2) into the language and as long as the execution does not raise a dynamic tag exception. It should therefore be considered some- what borderline parametric, since implementations must treat it uniformly but a dynamic tag error depends on the run-time type of a polymorphic value. Generally, whether polymorphism is parametric depends on all the details of the language definition.
    [Show full text]
  • Type Systems, Type Inference, and Polymorphism
    6 Type Systems, Type Inference, and Polymorphism Programming involves a wide range of computational constructs, such as data struc- tures, functions, objects, communication channels, and threads of control. Because programming languages are designed to help programmers organize computational constructs and use them correctly, many programming languages organize data and computations into collections called types. In this chapter, we look at the reasons for using types in programming languages, methods for type checking, and some typing issues such as polymorphism and type equality. A large section of this chap- ter is devoted to type inference, the process of determining the types of expressions based on the known types of some symbols that appear in them. Type inference is a generalization of type checking, with many characteristics in common, and a representative example of the kind of algorithms that are used in compilers and programming environments to determine properties of programs. Type inference also provides an introduction to polymorphism, which allows a single expression to have many types. 6.1 TYPES IN PROGRAMMING In general, a type is a collection of computational entities that share some common property. Some examples of types are the type Int of integers, the type Int!Int of functions from integers to integers, and the Pascal subrange type [1 .. 100] of integers between 1 and 100. In concurrent ML there is the type Chan Int of communication channels carrying integer values and, in Java, a hierarchy of types of exceptions. There are three main uses of types in programming languages: naming and organizing concepts, making sure that bit sequences in computer memory are interpreted consistently, providing information to the compiler about data manipulated by the program.
    [Show full text]
  • Parametric Polymorphism • Subtype Polymorphism • Definitions and Classifications
    Polymorphism Chapter Eight Modern Programming Languages 1 Introduction • Compare C++ and ML function types • The ML function is more flexible, since it can be applied to any pair of the same (equality-testable) type, C++ to only char type. int f(char a, char b) { C++: return a==b; } Haskell: f (a, b) = (a == b); f :: (a, a) -> Bool Chapter Eight Modern Programming Languages 2 Polymorphism • Functions with that extra flexibility are called polymorphic • A difficult word to define: Applies to a wide variety of language features Most languages have at least a little We will examine four major examples, then return to the problem of finding a definition that covers them Chapter Eight Modern Programming Languages 3 Outline • Overloading • Parameter coercion • Parametric polymorphism • Subtype polymorphism • Definitions and classifications Chapter Eight Modern Programming Languages 4 Overloading • An overloaded function name or operator is one that has at least two definitions, all of different types • For example, + and – operate on integers and reals • Most languages have overloaded operators • Some also allow the programmer to define new overloaded function names and operators Chapter Eight Modern Programming Languages 5 Predefined Overloaded Operators Haskell: x = 1 + 2; y = 1.0 + 2.0; Pascal: a := 1 + 2; b := 1.0 + 2.0; c := "hello " + "there"; d := ['a'..'d'] + ['f'] Chapter Eight Modern Programming Languages 6 Adding to Overloaded Operators • Some languages, like C++, allow additional meanings to be defined for operators class complex
    [Show full text]
  • Polymorphic Type Systems 1
    06-02552 Princ. of Progr. Languages (and “Extended”) The University of Birmingham Spring Semester 2018-19 School of Computer Science c Uday Reddy2018-19 Handout 6: Polymorphic Type Systems 1. Polymorphic functions A function that can take arguments of different types or return results of different types, is called a polymorphic function. Several examples of polymorphic functions were mentioned in Handout 1 (Extensional functions and set theory). Their types were written with type variables A; B; : : : using the conventional practice in Mathematics. Many of these examples again occurred in Handout 5 (Introduction to lambda calculus) where we wrote their types using type variables a; b; : : : using the Haskell convention of lower case letters for variables. For example, the identity function λx. x is of type A ! A for every type A (or a ! a in the Haskell convention). It can take arguments of any type A and return results of the same type A. The function fst is of type A ! B ! A and the function snd is of type A ! B ! B etc. More important polymorphic functions arise when we deal with data structures. Suppose List A is the type of lists with elements of type A. Then a function for selecting the element at a particular position has the type List A × Int ! A. So, the selection function can take as argument lists of different element types A and returns results of the same element type. A function for appending two lists has the type List A × List A ! List A. A function to sort a list using a particular comparison function has the type (A × A ! Bool) ! List A ! List A, where the first argument is a comparison function for values of type A and the second argument is a list over the same type A.
    [Show full text]
  • 1 Parametric Polymorphism
    CS 4110 – Programming Languages and Logics .. Lecture #22: Polymorphism . 1 Parametric polymorphism Polymorphism (Greek for “many forms”) is the ability for code to be used with values of different types. For example, a polymorphic function is one that can be invoked with arguments of different types. A polymorphic datatype is one that can contain elements of different types. Several kinds of polymorphism are commonly used in modern programming languages. • Subtype polymorphism allows a term to have many types using the subsumption rule. For example, a function with argument τ can operate on any value with a type that is a subtype of τ. • Ad-hoc polymorphism usually refers to code that appears to be polymorphic to the programmer, but the actual implementation is not. A typical example is overloading: using the same function name for functions with different kinds of parameters. Although it looks like a polymorphic function to the code that uses it, there are actually multiple function implementations (none being polymorphic) and the compiler invokes the appropriate one. Ad-hoc polymorphism is a dispatch mechanism: the type of the arguments is used to determine (either at compile time or run time) which code to invoke. • Parametric polymorphism refers to code that is written without knowledge of the actual type of the arguments; the code is parametric in the type of the parameters. Examples include polymorphic functions in ML and Java generics. In this lecture we will consider parametric polymorphism in detail. Suppose we are working in the simply- typed lambda calculus, and consider a “doubling” function for integers that takes a function f, and an integer x, applies f to x, and then applies f to the result.
    [Show full text]
  • CS 4110 – Programming Languages and Logics Lecture #22: Polymorphism
    CS 4110 – Programming Languages and Logics Lecture #22: Polymorphism 1 Parametric polymorphism Polymorphism (Greek for “many forms”) is the ability for code to be used with values of different types. For example, a polymorphic function is one that can be invoked with arguments of different types. A polymorphic datatype is one that can contain elements of different types. There are several different kinds of polymorphism that are commonly used in modern pro- gramming languages. • Subtype polymorphism allows a term to have many types using the subsumption rule, which 0 allows a value of type τ to masquerade as a value of type τ provided that τ is a subtype of 0 τ . • Ad-hoc polymorphism usually refers to code that appears to be polymorphic to the program- mer, but the actual implementation is not. For example, languages with overloading allow the same function name to be used with functions that take different types of parameters. Although it looks like a polymorphic function to the code that uses it, there are actually multiple function implementations (none being polymorphic) and the compiler invokes the appropriate one. Ad-hoc polymorphism is a dispatch mechanism: the type of the arguments is used to determine (either at compile time or run time) which code to invoke. • Parametric polymorphism refers to code that is written without knowledge of the actual type of the arguments; the code is parametric in the type of the parameters. Examples include polymorphic functions in ML and Java generics. In this lecture we will consider parametric polymorphism in detail. As a motivating example, suppose we are working in the simply-typed λ-calculus, and consider a “doubling” function for integers that takes a function f, and an integer x, applies f to x, and then applies f to the result.
    [Show full text]
  • Object-Oriented Programming
    Programming Languages Third Edition Chapter 5 Object-Oriented Programming Objectives • Understand the concepts of software reuse and independence • Become familiar with the Smalltalk language • Become familiar with the Java language • Become familiar with the C++ language • Understand design issues in object-oriented languages • Understand implementation issues in object- oriented languages Programming Languages, Third Edition 2 1 Introduction • Object-oriented programming languages began in the 1960s with Simula – Goals were to incorporate the notion of an object, with properties that control its ability to react to events in predefined ways – Factor in the development of abstract data type mechanisms – Crucial to the development of the object paradigm itself Programming Languages, Third Edition 3 Introduction (cont’d.) • By the mid-1980s, interest in object-oriented programming exploded – Almost every language today has some form of structured constructs Programming Languages, Third Edition 4 2 Software Reuse and Independence • Object-oriented programming languages satisfy three important needs in software design: – Need to reuse software components as much as possible – Need to modify program behavior with minimal changes to existing code – Need to maintain the independence of different components • Abstract data type mechanisms can increase the independence of software components by separating interfaces from implementations Programming Languages, Third Edition 5 Software Reuse and Independence (cont’d.) • Four basic ways a software
    [Show full text]
  • Contextual Polymorphism
    Contextual Polymorphism by Glen Jerey Ditcheld A thesis presented to the University of Waterloo in fullment of the thesis requirement for the degree of Do ctor of Philosophy in Computer Science Waterloo Ontario Canada c Glen Jerey Ditcheld I hereby declare that I am the sole author of this thesis I authorize the University of Waterloo to lend this thesis to other institutions or individuals for the purp ose of scholarly research I further authorize the University of Waterloo to repro duce this thesis by photo copying or by other means in total or in part at the request of other institutions or individuals for the purp ose of scholarly research ii The University of Waterloo requires the signatures of all p ersons using or photo copying this thesis Please sign b elow and give address and date iii Abstract Programming languages often provide for various sorts of static type checking as a way of detecting invalid programs However statically checked type systems often require unnecessarily sp ecic type information which leads to frustratingly inexible languages Polymorphic type systems restore exibility by allowing entities to take on more than one type This thesis discusses p olymorphism in statically typed programming languages It provides precise denitions of the term p olymorphism and for its varieties adhoc p olymorphism uni versal p olymorphism inclusion p olymorphism and parametric p olymorphism and surveys and compares many existing mechanisms for providing p olymorphism in programming languages Finally it introduces a new p olymorphism
    [Show full text]
  • 07B-Generics.Pdf
    ======================================== Polymorphism and Generics Recall from chapter 3: ad hoc polymorphism: fancy name for overloading subtype polymorphism in OO languages allows code to do the "right thing" when a ref of parent type refers to an object of child type implemented with vtables (to be discussed in chapter 9) parametric polymorphism type is a parameter of the code, implicitly or explicitly implicit (true) language implementation figures out what code requires of object at compile-time, as in ML or Haskell at run-time, as in Lisp, Smalltalk, or Python lets you apply operation to object only if object has everything the code requires explicit (generics) programmer specifies the type parameters explcitly mostly what I want to talk about today ---------------------------------------- Generics found in Clu, Ada, Modula-3, C++, Eiffel, Java 5, C# 2.0, ... C++ calls its generics templates. Allow you, for example, to create a single stack abstraction, and instantiate it for stacks of integers, stacks of strings, stacks of employee records, ... template <class T> class stack { T[100] contents; int tos = 0; // first unused location public: T pop(); void push(T); ... } ... stack<double> S; I could, of course, do class stack { void*[100] contents; int tos = 0; public: void* pop(); void push(void *); ... } But then I have to use type casts all over the place. Inconvenient and, in C++, unsafe. Lots of containers (stacks, queues, sets, strings, mappings, ...) in the C++ standard library. Similarly rich libraries exist for Java and C#. (Also for Python and Ruby, but those use implicit parametric polymorphism with run-time checking.) ---------------------------------------- Some languages (e.g.
    [Show full text]
  • Parametric Polymorphism
    Lecture Notes on Parametric Polymorphism 15-814: Types and Programming Languages Frank Pfenning Lecture 11 October 9, 2018 1 Introduction Polymorphism refers to the possibility of an expression to have multiple types. In that sense, all the languages we have discussed so far are polymorphic. For example, we have λx. x : τ ! τ for any type τ. More specifically, then, we are interested in reflecting this property in a type itself. For example, the judgment λx. x : 8α: α ! α expresses all the types above, but now in a single form. This means we can now reason within the type system about polymorphic functions rather than having to reason only at the metalevel with statements such as “for all types τ, :::”. Christopher Strachey [Str00] distinguished two forms of polymorphism: ad hoc polymorphism and parametric polymorphism. Ad hoc polymorphism refers to multiple types possessed by a given expression or function which has different implementations for different types. For example, plus might have type int ! int ! int but als float ! float ! float with different implemen- tations at these two types. Similarly, a function show : 8α: α ! string might convert an argument of any type into a string, but the conversion function itself will of course have to depend on the type of the argument: printing Booleans, integers, floating point numbers, pairs, etc. are all very different LECTURE NOTES OCTOBER 9, 2018 L11.2 Parametric Polymorphism operations. Even though it is an important concept in programming lan- guages, in this lecture we will not be concerned with ad hoc polymorphism. In contrast, parametric polymorphism refers to a function that behaves the same at all possible types.
    [Show full text]