Type Classes

Total Page:16

File Type:pdf, Size:1020Kb

Type Classes Type Classes Slide 1 - Title Hello, and welcome to CS 421. In a programming language, we often want to apply an operation to more than one kind of thing. For example, in most programming languages, the plus operator normally works on both integers and floating point numbers, without needing to be distinguished in any way. When a function or operation is allowed to work on more than one type, it is said to be polymorphic. Slide 2 - Objectives When you are done with this video, you will be able to describe polymorphism and list several ways of accomplishing it. You will also be able to describe Haskell’s type classes and use them to define some polymorphic functions. Slide 3 - Polymorphism It is very common to want to use the same “thing”, such as a function, an operator, or a container, over many types. Different languages have developed different ways to handle this. In C++, we have function overloading, also called ad hoc polymorphism. Many languages support a form of objects and inheritance, which allows similar types to be grouped together. Languages like Haskell and OCaml that have Hindley Milner type systems support parameterized types such as lists, and languages like C++ and Java support templated classes, or generics. Haskell supports a construct called a type class, which we will talk about in great detail. Slide 4 - Overloading Here is an example of overloading in C++. You see here we have two functions named inc. We’d like this function to work on both integers and doubles, so we declare the function twice. This was a huge improvement over the C programming language. In C, you would have to give the functions different names so that the compiler could distinguish between them. So, you might have a function incInteger and another function incDouble. As you can imagine, this gets tedious quickly if you have a lot of types you want to operate on. The way C++ does it is by a process called mangling. The compiler uses the types of the parameters as part of the name, which allows it to tell them apart. This is similar to what we had to do in C, but it’s all handled by the compiler for us. Slide 5 - Inheritance Here’s an example in Java of inheritance. We have a class Shape and another class Square that inherits from Shape. We can have a collection of objects that inherit from Shape and loop over them, knowing they all support certain fields or operations. I’m assuming you’ve worked with this before, so I am not going to go into much detail now, but we will talk about objects in more detail in a future lecture. 1 Slide 6 - Parametric Polymorphism Parametric polymorphism allows your types to have a parameter of some kind, and is often used for types that are meant to be containers, though that’s not the only use for them. Java calls them generics, and C++ calls them templates. In Haskell they are called parameterized types. Slide 7 - The Eq Type Class Let’s talk about type classes now. A type class is a collection of types that support a set of functions. Here is the Eq type class, for types that support equality. This declaration says that a type a is a member of the Eq type class if it supports == and not =. The second line of the declaration gives the types of the functions we want to support. The last two lines give default definitions. Later on, when you declare a type to be a member of this class, you have the option of giving your own definition of these functions or keepig the default definition. Notice that == and not= are defined recursively in terms of each other. This allows you to define one of the two, and as a result you will get the other one automatically. Slide 8 - Using Eq The reason for an Eq type class is that Haskell does not define equality for user-defined types automatically. For one thing, not all types can be compared: functions for instance. For another thing, we may have different ideas about when we want to consider two pieces of data to be equal. For example, you may have a node type that contains data and a comment field, and maybe you don’t want the comment field to be considered when you compare for equality. In this example, I’ve created a type Foo and made two variables x and y both assigned to Foo 10. If we try to compare them, we get this error message. This is an indication that we did not make Foo a member of the Eq type class. Let’s look at how to do that. Slide 9 - Use an Instance The instance keyword is how we declare a type to be a member of a type class. Here I’ve told Haskell that Foo is a member of Eq, and given the definition for equality. It will get the default definition of not = from the class declaration. Now == works for x and y. Slide 10 - tl;dc Too long! Didn’t code! There are many type classes in Haskell, and many of those are very basic. If you are thinking that the compiler should be able to make Foo an instance of Eq for us, you would be right. The Haskell implementers thought the same thing, so they put in a keyword deriving that we can use to tell the compiler to make Foo an instance of a type class for us. Let’s take a look at some of the other basic type classes. Slide 11 - The Ord Typeclass Ord is not just the code for Chicago’s O’Hare airport! In Haskell, the Ord typeclass indicates that a type has an ordering. The minimal definition is the compare function, though you could define the operators instead. 2 One thing that is a bit unusual about this type is that it makes use of another type called Ordering, which has three members: LT, GT, and EQ. You may want to pause the video and review the functions to see how it makes use of these. Resume when you are ready to see the next type class. Slide 12 - The Show Typeclass To convert an instance of a type into a string we have the Show typeclass. It has just one function, show. Usually we use a deriving clause to have the compiler write show for us, but sometimes it is preferable to supply our own definition. Slide 13 - The Read Typeclass The Read typeclass is the opposite of show. It converts a string into a member of the given type. You’ll note that if you want to use read, you have to tell Haskell the type that you expect to get back. One of the consequences of type classes is that type inferencing, in which Haskell automatically determines the types of things for us, is not always decidable. Like Show, we can derive Read to have the function created for us. Those are some of the basic type classes. You have also seen Num for numeric types, and you may have seen Integral for types that support modulus. There are many other type classes that come with Haskell, and in the next video we will go over the Functor and Applicative type classes, which allow some more advanced operations on user-defined types. 3.
Recommended publications
  • 1=Haskell =1=Making Our Own Types and Typeclasses
    Haskell Making Our Own Types and Typeclasses http://igm.univ-mlv.fr/~vialette/?section=teaching St´ephaneVialette LIGM, Universit´eParis-Est Marne-la-Vall´ee November 13, 2016 Making Our Own Types and Typeclasses Algebraic data types intro So far, we've run into a lot of data types: Bool, Int, Char, Maybe, etc. But how do we make our own? One way is to use the data keyword to define a type. Let's see how the Bool type is defined in the standard library. data Bool= False| True data means that we're defining a new data type. Making Our Own Types and Typeclasses Algebraic data types intro data Bool= False| True The part before the = denotes the type, which is Bool. The parts after the = are value constructors. They specify the different values that this type can have. The | is read as or. So we can read this as: the Bool type can have a value of True or False. Both the type name and the value constructors have to be capital cased. Making Our Own Types and Typeclasses Algebraic data types intro We can think of the Int type as being defined like this: data Int=-2147483648|-2147483647| ...|-1|0|1|2| ...| 2147483647 The first and last value constructors are the minimum and maximum possible values of Int. It's not actually defined like this, the ellipses are here because we omitted a heapload of numbers, so this is just for illustrative purposes. Shape let's think about how we would represent a shape in Haskell.
    [Show full text]
  • A Polymorphic Type System for Extensible Records and Variants
    A Polymorphic Typ e System for Extensible Records and Variants Benedict R. Gaster and Mark P. Jones Technical rep ort NOTTCS-TR-96-3, November 1996 Department of Computer Science, University of Nottingham, University Park, Nottingham NG7 2RD, England. fbrg,[email protected] Abstract b oard, and another indicating a mouse click at a par- ticular p oint on the screen: Records and variants provide exible ways to construct Event = Char + Point : datatyp es, but the restrictions imp osed by practical typ e systems can prevent them from b eing used in ex- These de nitions are adequate, but they are not par- ible ways. These limitations are often the result of con- ticularly easy to work with in practice. For example, it cerns ab out eciency or typ e inference, or of the di- is easy to confuse datatyp e comp onents when they are culty in providing accurate typ es for key op erations. accessed by their p osition within a pro duct or sum, and This pap er describ es a new typ e system that reme- programs written in this way can b e hard to maintain. dies these problems: it supp orts extensible records and To avoid these problems, many programming lan- variants, with a full complement of p olymorphic op era- guages allow the comp onents of pro ducts, and the al- tions on each; and it o ers an e ective type inference al- ternatives of sums, to b e identi ed using names drawn gorithm and a simple compilation metho d.
    [Show full text]
  • CSE 307: Principles of Programming Languages Classes and Inheritance
    OOP Introduction Type & Subtype Inheritance Overloading and Overriding CSE 307: Principles of Programming Languages Classes and Inheritance R. Sekar 1 / 52 OOP Introduction Type & Subtype Inheritance Overloading and Overriding Topics 1. OOP Introduction 3. Inheritance 2. Type & Subtype 4. Overloading and Overriding 2 / 52 OOP Introduction Type & Subtype Inheritance Overloading and Overriding Section 1 OOP Introduction 3 / 52 OOP Introduction Type & Subtype Inheritance Overloading and Overriding OOP (Object Oriented Programming) So far the languages that we encountered treat data and computation separately. In OOP, the data and computation are combined into an “object”. 4 / 52 OOP Introduction Type & Subtype Inheritance Overloading and Overriding Benefits of OOP more convenient: collects related information together, rather than distributing it. Example: C++ iostream class collects all I/O related operations together into one central place. Contrast with C I/O library, which consists of many distinct functions such as getchar, printf, scanf, sscanf, etc. centralizes and regulates access to data. If there is an error that corrupts object data, we need to look for the error only within its class Contrast with C programs, where access/modification code is distributed throughout the program 5 / 52 OOP Introduction Type & Subtype Inheritance Overloading and Overriding Benefits of OOP (Continued) Promotes reuse. by separating interface from implementation. We can replace the implementation of an object without changing client code. Contrast with C, where the implementation of a data structure such as a linked list is integrated into the client code by permitting extension of new objects via inheritance. Inheritance allows a new class to reuse the features of an existing class.
    [Show full text]
  • Java Secrets.Pdf
    Java Secrets by Elliotte Rusty Harold IDG Books, IDG Books Worldwide, Inc. ISBN: 0764580078 Pub Date: 05/01/97 Buy It Preface About the Author Part I—How Java Works Chapter 1—Introducing Java SECRETS A Little Knowledge Can Be a Dangerous Thing What’s in This Book? Part I: How Java Works Part II: The sun Classes Part III: Platform-Dependent Java Why Java Secrets? Broader applicability More power Inspiration Where Did the Secrets Come From? Where is the documentation? The source code The API documentation What Versions of Java Are Covered? Some Objections Java is supposed to be platform independent Why aren’t these things documented? FUD (fear, uncertainty, and doubt) How secret is this, anyway? Summary Chapter 2—Primitive Data Types Bytes in Memory Variables, Values, and Identifiers Place-Value Number Systems Binary notation Hexadecimal notation Octal notation Integers ints Long, short, and byte Floating-Point Numbers Representing floating-point numbers in binary code Special values Denormalized floating-point numbers CHAR ASCII ISO Latin-1 Unicode UTF8 Boolean Cross-Platform Issues Byte order Unsigned integers Integer widths Conversions and Casting Using a cast The mechanics of conversion Bit-Level Operators Some terminology Bitwise operators Bit shift operators Summary Chapter 2—Primitive Data Types Bytes in Memory Variables, Values, and Identifiers Place-Value Number Systems Binary notation Hexadecimal notation Octal notation Integers ints Long, short, and byte Floating-Point Numbers Representing floating-point numbers in binary code
    [Show full text]
  • Lecture Slides
    Outline Meta-Classes Guy Wiener Introduction AOP Classes Generation 1 Introduction Meta-Classes in Python Logging 2 Meta-Classes in Python Delegation Meta-Classes vs. Traditional OOP 3 Meta-Classes vs. Traditional OOP Outline Meta-Classes Guy Wiener Introduction AOP Classes Generation 1 Introduction Meta-Classes in Python Logging 2 Meta-Classes in Python Delegation Meta-Classes vs. Traditional OOP 3 Meta-Classes vs. Traditional OOP What is Meta-Programming? Meta-Classes Definition Guy Wiener Meta-Program A program that: Introduction AOP Classes One of its inputs is a program Generation (possibly itself) Meta-Classes in Python Its output is a program Logging Delegation Meta-Classes vs. Traditional OOP Meta-Programs Nowadays Meta-Classes Guy Wiener Introduction AOP Classes Generation Compilers Meta-Classes in Python Code Generators Logging Delegation Model-Driven Development Meta-Classes vs. Traditional Templates OOP Syntactic macros (Lisp-like) Meta-Classes The Problem With Static Programming Meta-Classes Guy Wiener Introduction AOP Classes Generation Meta-Classes How to share features between classes and class hierarchies? in Python Logging Share static attributes Delegation Meta-Classes Force classes to adhere to the same protocol vs. Traditional OOP Share code between similar methods Meta-Classes Meta-Classes Guy Wiener Introduction AOP Classes Definition Generation Meta-Classes in Python Meta-Class A class that creates classes Logging Delegation Objects that are instances of the same class Meta-Classes share the same behavior vs. Traditional OOP Classes that are instances of the same meta-class share the same behavior Meta-Classes Meta-Classes Guy Wiener Introduction AOP Classes Definition Generation Meta-Classes in Python Meta-Class A class that creates classes Logging Delegation Objects that are instances of the same class Meta-Classes share the same behavior vs.
    [Show full text]
  • Haskell-Style Type Classes with Isabelle/Isar
    Isar ∀ Isabelle= α λ β → Haskell-style type classes with Isabelle/Isar Florian Haftmann 20 February 2021 Abstract This tutorial introduces Isar type classes, which are a convenient mech- anism for organizing specifications. Essentially, they combine an op- erational aspect (in the manner of Haskell) with a logical aspect, both managed uniformly. 1 INTRODUCTION 1 1 Introduction Type classes were introduced by Wadler and Blott [8] into the Haskell lan- guage to allow for a reasonable implementation of overloading1. As a canon- ical example, a polymorphic equality function eq :: α ) α ) bool which is overloaded on different types for α, which is achieved by splitting introduc- tion of the eq function from its overloaded definitions by means of class and instance declarations: 2 class eq where eq :: α ) α ) bool instance nat :: eq where eq 0 0 = True eq 0 - = False eq - 0 = False eq (Suc n)(Suc m) = eq n m instance (α::eq; β::eq) pair :: eq where eq (x1; y1) (x2; y2) = eq x1 x2 ^ eq y1 y2 class ord extends eq where less-eq :: α ) α ) bool less :: α ) α ) bool Type variables are annotated with (finitely many) classes; these annotations are assertions that a particular polymorphic type provides definitions for overloaded functions. Indeed, type classes not only allow for simple overloading but form a generic calculus, an instance of order-sorted algebra [5, 6, 10]. From a software engineering point of view, type classes roughly correspond to interfaces in object-oriented languages like Java; so, it is naturally desirable that type classes do not only provide functions (class parameters) but also state specifications implementations must obey.
    [Show full text]
  • OMG Meta Object Facility (MOF) Core Specification
    Date : October 2019 OMG Meta Object Facility (MOF) Core Specification Version 2.5.1 OMG Document Number: formal/2019-10-01 Standard document URL: https://www.omg.org/spec/MOF/2.5.1 Normative Machine-Readable Files: https://www.omg.org/spec/MOF/20131001/MOF.xmi Informative Machine-Readable Files: https://www.omg.org/spec/MOF/20131001/CMOFConstraints.ocl https://www.omg.org/spec/MOF/20131001/EMOFConstraints.ocl Copyright © 2003, Adaptive Copyright © 2003, Ceira Technologies, Inc. Copyright © 2003, Compuware Corporation Copyright © 2003, Data Access Technologies, Inc. Copyright © 2003, DSTC Copyright © 2003, Gentleware Copyright © 2003, Hewlett-Packard Copyright © 2003, International Business Machines Copyright © 2003, IONA Copyright © 2003, MetaMatrix Copyright © 2015, Object Management Group Copyright © 2003, Softeam Copyright © 2003, SUN Copyright © 2003, Telelogic AB Copyright © 2003, Unisys USE OF SPECIFICATION - TERMS, CONDITIONS & NOTICES The material in this document details an Object Management Group specification in accordance with the terms, conditions and notices set forth below. This document does not represent a commitment to implement any portion of this specification in any company's products. The information contained in this document is subject to change without notice. LICENSES The companies listed above have granted to the Object Management Group, Inc. (OMG) a nonexclusive, royalty-free, paid up, worldwide license to copy and distribute this document and to modify this document and distribute copies of the modified version. Each of the copyright holders listed above has agreed that no person shall be deemed to have infringed the copyright in the included material of any such copyright holder by reason of having used the specification set forth herein or having conformed any computer software to the specification.
    [Show full text]
  • Polymorphism
    Polymorphism A closer look at types.... Chap 8 polymorphism º comes from Greek meaning ‘many forms’ In programming: Def: A function or operator is polymorphic if it has at least two possible types. Polymorphism i) OverloaDing Def: An overloaDeD function name or operator is one that has at least two Definitions, all of Different types. Example: In Java the ‘+’ operator is overloaDeD. String s = “abc” + “def”; +: String * String ® String int i = 3 + 5; +: int * int ® int Polymorphism Example: Java allows user DefineD polymorphism with overloaDeD function names. bool f (char a, char b) { return a == b; f : char * char ® bool } bool f (int a, int b) { f : int * int ® bool return a == b; } Note: ML Does not allow function overloaDing Polymorphism ii) Parameter Coercion Def: An implicit type conversion is calleD a coercion. Coercions usually exploit the type-subtype relationship because a wiDening type conversion from subtype to supertype is always DeemeD safe ® a compiler can insert these automatically ® type coercions. Example: type coercion in Java Double x; x = 2; the value 2 is coerceD from int to Double by the compiler Polymorphism Parameter coercion is an implicit type conversion on parameters. Parameter coercion makes writing programs easier – one function can be applieD to many subtypes. Example: Java voiD f (Double a) { ... } int Ì double float Ì double short Ì double all legal types that can be passeD to function ‘f’. byte Ì double char Ì double Note: ML Does not perform type coercion (ML has no notion of subtype). Polymorphism iii) Parametric Polymorphism Def: A function exhibits parametric polymorphism if it has a type that contains one or more type variables.
    [Show full text]
  • C/C++ Program Design CS205 Week 10
    C/C++ Program Design CS205 Week 10 Prof. Shiqi Yu (于仕琪) <[email protected]> Prof. Feng (郑锋) <[email protected]> Operators for cv::Mat Function overloading More convenient to code as follows Mat add(Mat A, Mat B); Mat A, B; Mat add(Mat A, float b); float a, b; Mat add(float a, Mat B); //… Mat C = A + B; Mat mul(Mat A, Mat B); Mat D = A * B; Mat mul(Mat A, float b); Mat E = a * A; Mat mul(float a, Mat B); ... operators for cv::Mat #include <iostream> #include <opencv2/opencv.hpp> using namespace std; int main() { float a[6]={1.0f, 1.0f, 1.0f, 2.0f, 2.0f, 2.0f}; float b[6]={1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}; cv::Mat A(2, 3, CV_32FC1, a); cv::Mat B(3, 2, CV_32FC1, b); cv::Mat C = A * B; cout << "Matrix C = " << endl << C << endl; return 0; } The slides are based on the book <Stephen Prata, C++ Primer Plus, 6th Edition, Addison-Wesley Professional, 2011> Operator Overloading Overloading • Function overloading Ø Let you use multiple functions sharing the same name Ø Relationship to others: üDefault arguments üFunction templates • * operator (An operator overloading example) Ø Applied to an address, yield the value stored at that address Ø Applied two numbers, yield the product of the values Operator Function • Operator function Ø Keyword: operator for C++ Ø To overload an operator, you use a special function Ø Function header has the form: üoperator+() overloads the + operator üoperator*() overloads the * operator üoperator[]() overloads the [] operator Ø The compiler, recognizing the operands as belonging to the class, replaces the
    [Show full text]
  • CHAPTER-3 Function Overloading SHORT ANSWER QUESTIONS 1
    CHAPTER-3 Function Overloading SHORT ANSWER QUESTIONS 1. How does the compiler interpret more than one definitions having same name? What steps does it follow to distinguish these? Ans. The compiler will follow the following steps to interpret more than one definitions having same name: (i) if the signatures of subsequent functions match the previous function’s, then the second is treated as a re- declaration of the first. (ii) if the signature of the two functions match exactly but the return type differ, the second declaration is treated as an erroneous re-declaration of the first and is flagged at compile time as an error. (iii) if the signature of the two functions differ in either the number or type of their arguments, the two functions are considered to be overloaded. 2. Discuss how the best match is found when a call to an overloaded function is encountered? Give example(s) to support your answer. Ans. In order to find the best possible match, the compiler follows the following steps: 1. Search for an exact match is performed. If an exact match is found, the function is invoked. For example, 2. If an exact match is not found, a match trough promotion is searched for. Promotion means conversion of integer types char, short, enumeration and int into int or unsigned int and conversion of float into double. 3. If first two steps fail then a match through application of C++ standard conversion rules is searched for. 4. If all the above mentioned steps fail, a match through application of user-defined conversions and built-in conversion is searched for.
    [Show full text]
  • 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]