Course year Typeclasses and their instances

Transcription

1 Course year Typeclasses and their instances Doaitse Swierstra and Atze Dijkstra with extra s Utrecht University September 29, 2016

2 1. The basics 2

3 Overloading versus parametric polymorphism 1 Many functions can be applied to values of different types. 3

4 Overloading versus parametric polymorphism 1 Many functions can be applied to values of different types. There are two underlying principles: A parametrically polymorphic function works on some specific data structure, without making explicit use of properties of the elements contained. Examples are length, concat, (.) and map. 3

5 Overloading versus parametric polymorphism 1 Many functions can be applied to values of different types. There are two underlying principles: A parametrically polymorphic function works on some specific data structure, without making explicit use of properties of the elements contained. Examples are length, concat, (.) and map. An overloaded function also works on different types, but then the implementations differ; they only share the name. Examples are +, for which one version adds Ints and another Floats. The operator <= has versions for Int, Float, Char, tuples and lists. 3

6 Why type classes? (1) 1 What problem are we solving? Consider sort :: [Int] > [Int] sort = foldr insert [ ] insert x [ ] = [x] insert x xs@(y : ys) x <= y = x : xs true = y : insert x ys 4

7 Why type classes? (1) 1 What problem are we solving? Consider sort :: [Int] > [Int] sort = foldr insert [ ] insert x [ ] = [x] insert x xs@(y : ys) x <= y = x : xs true = y : insert x ys We can also pass the comparison function, that compares values of the right type, a: sort :: (a > a > Bool) > [a] > [a] sort lte = foldr (insert lte) [ ] insert lte x xs@(y : ys) x lte y = x : xs true = y : insert lte x ys 4

8 Why type classes? (2) 1 Recall sort :: (a > a > Bool) > [a] > [a] sort lte = foldr (insert lt) [ ] insert lte x xs@(y : ys) x lte y = x : xs true = y : insert x ys Wouldn t it be nice not to have to pass around lte all the time? And to decide which lte to use, based on the actual type of the values passed to sort? 5

9 Why type classes? (2) 1 Recall sort :: (a > a > Bool) > [a] > [a] sort lte = foldr (insert lt) [ ] insert lte x xs@(y : ys) x lte y = x : xs true = y : insert x ys Wouldn t it be nice not to have to pass around lte all the time? And to decide which lte to use, based on the actual type of the values passed to sort? Indeed it can: by means of type classes we can state for every comparable type how it should be compared. Then the compiler can figure out which comparison function to use. 5

10 Classes 1 A class definition specifies a coherent collection of overloaded function names with their types. Instances of a class provide the specific function definitions (for a given type). The types Int and Float are instances of the class Num. 6

11 Classes 1 A class definition specifies a coherent collection of overloaded function names with their types. Instances of a class provide the specific function definitions (for a given type). The types Int and Float are instances of the class Num. The operator (+) is defined for each type that is an instance of the class Num. 6

12 Classes 1 A class definition specifies a coherent collection of overloaded function names with their types. Instances of a class provide the specific function definitions (for a given type). The types Int and Float are instances of the class Num. The operator (+) is defined for each type that is an instance of the class Num.This fact is expressed by the type of the operator +: (+) :: Num a => a > a > a 6

13 Classes 1 A class definition specifies a coherent collection of overloaded function names with their types. Instances of a class provide the specific function definitions (for a given type). The types Int and Float are instances of the class Num. The operator (+) is defined for each type that is an instance of the class Num.This fact is expressed by the type of the operator +: (+) :: Num a => a > a > a One can read this as: + has type a > a > a provided there is proof that a in an instance of Num. 6

14 Classes 1 A class definition specifies a coherent collection of overloaded function names with their types. Instances of a class provide the specific function definitions (for a given type). The types Int and Float are instances of the class Num. The operator (+) is defined for each type that is an instance of the class Num.This fact is expressed by the type of the operator +: (+) :: Num a => a > a > a One can read this as: + has type a > a > a provided there is proof that a in an instance of Num. 6 One can think of Num a => as an extra implicit argument, containing the actual definition of the specific (+).

15 A different outlook 1 Type classes may remind you of a record, or an interface or abstract class from the OO world Instances correspond at run-time to so called dictionaries They contain concrete implementations of functions (and constants) listed in the type class When we use such functions, the compiler can find the dictionary to use based on the actual types If you add Ints you use a different dictionary then if you add Floats Since the type decides the dictionary, you can have only one implementation per type (can you, really?) 7

16 Class and instance declarations 1 Besides the standard classes (such as Num, Eq and Ord) you can define your own classes This is a very powerful technique to parametrize your code without too much effort Many Haskell libraries depend extensively on these concepts It does make programs harder to debug: you see a function call overloadedfun of which many instances exist. If it generates an exception, which instance is to blame? 8

17 The first version of the class Num 1 A simple variant of the class Num from the Prelude is: class Num a where (+), ( ), ( ), (/) :: a > a > a negate :: a > a 9

18 class declarations 1 A class declaration consists of the following elements: the keyword class; the name of the class (Num in our case); a type-variable (a in our case); the keyword where; type declarations for operators en functions, in which the type parameter of the class may occur. The functions can be polymorphic. 10

19 The instance Num Int 1 In an instance declaration we provide definitions for the functions and operators of the class for a specific type: 11

20 The instance Num Int 1 In an instance declaration we provide definitions for the functions and operators of the class for a specific type: instance Num Int where (+) = primplusint ( ) = primminusint ( ) = primmulint (/) = primdivint negate = primnegint 11

21 Instance declarations 1 An instance declaration contains the following parts: the keyword instance; the name of a declared class (Num); the type for which we are declaring an instance (Int); the keyword where; definitions for the functions and operators of the class for this specific type 12

22 Num Float 1 instance Num Float where (+) = primplusfloat ( ) = primminusfloat ( ) = primmulfloat (/) = primdivfloat negate = primnegfloat 13

23 Defining new instances 1 We can make the rational numbers an instance of Num too: data Rational = Rat (Int, Int) instance Num Rational where Rat (x, y) + Rat (p, q) = simplify (Rat (x q + y p, y q)) Rat (x, y) Rat (p, q) = simplify (Rat (x q y p, y q)) Rat (x, y) Rat (p, q) = simplify (Rat (x p, y q)) Rat (x, y) / Rat (p, q) = simplify (Rat (x q, y p)) negate (Rat (x, y)) = Rat (negate x, y) simplify (Rat (x, y)) = Rat (x div f, y div f ) where f = gcd x y 14

24 Defining a new type class 1 (Taken from Learn You A Haskell For Great Good!) JavaScript (and many other languages) allows you to write anything inside a condition Each type has special rules on how to interpret them as booleans We shall use type classes to attain the same thing here 15

25 A class for coercion 1 class YesNo a where yesno :: a > Bool Essentially, an instance of yesno tells us for a value of that instance whether it coerces to True or to False 16

26 What about instances 1 instance YesNo Bool where yesno = id instance YesNo Int where yesno 0 = False yesno = True instance YesNo [a] where yesno [ ] = False yesno = True And on and on... Note that the list case does not depend on having a YesNo instance for a 17

27 Example uses 1? yesno (length []) False? yesno "bleep" True? yesno "" False? yesno True True? yesno [] False? yesno [0,0,0] True 18

28 Dynamic languages are hard to model 1? yesno "0" True? yesno "a" True? yesno [0] True Can we have that 0 is also False, but keep the others True? That is a bit harder, since we then want to give [Char] other rules than other [a]. Allowing overlapping might just work Modelling different languages is even harder, since they do not correspond on these special cases 19

29 2. Back to the standard classes 20

30 Eq 2 The Prelude contains the definition of Eq: class Eq a where (==), (/ =) :: a > a > Bool 21

31 and definitions for all the standard types 2 22 instance Eq Int where x == y = primeqint x y x/ = y = not (x == y) instance Eq Float where x == y = primeqfloat x y x/ = y = not (x == y) instance Eq Char where x == y = ord x == ord y x/ = y = not (x == y) instance Eq Bool where True == True = True False == False = True True == False = False False == True = False x/ = y = not (x == y)

32 Eq revisited 2 class Eq a where (==), (/ =) :: a > a > Bool x/ = y = not (x == y) x == y = not (x/ = y) If we define an instance and omit either == or / =, then the default definition is taken. 23

33 Eq revisited 2 class Eq a where (==), (/ =) :: a > a > Bool x/ = y = not (x == y) x == y = not (x/ = y) If we define an instance and omit either == or / =, then the default definition is taken. Do not forget to provide at least one! 23

34 Using Eq instances in defining new instances 2 We can make Rational an instance of Eq instance Eq Rational where Rat (x, y) == Rat (p, q) = x q == y p 24

35 Using Eq instances in defining new instances 2 We can make Rational an instance of Eq instance Eq Rational where Rat (x, y) == Rat (p, q) = x q == y p The == in the left hand side of the definition refers to equality for Rationals which is being defined here, whereas the == in the right hand side refers to equality for Int s. 24

36 Super classes 2 In the class definition of Ord we can require that the types which will be instances of Ord have to be instances of Eq too: class Eq a => Ord a where (<=), (<), (>=), (>) :: a > a > Bool max, min :: a > a > a All functions except <= have default definitions, expressed in terms of <= and ==. 25

37 The class Num 2 Num also requires its instances to be instance of Eq: class Eq a => Num a where (+), ( ), ( ), (/) :: a > a > a negate :: a > a There is no semantic reason for this; it is a way of expressing the intentions of the library designers. 26

38 Parameterised instances 2 By giving a single definition we can make all lists an instance of Eq: instance Eq a => Eq [a] where [ ] == [ ] = True [ ] == (y : ys) = False (x : xs) == [ ] = False (x : xs) == (y : ys) = x == y && xs == ys We have a single definition covering an infinite number of instances. 27

39 Parameterised instances 2 By giving a single definition we can make all lists an instance of Eq: instance Eq a => Eq [a] where [ ] == [ ] = True [ ] == (y : ys) = False (x : xs) == [ ] = False (x : xs) == (y : ys) = x == y && xs == ys We have a single definition covering an infinite number of instances. One may read the first line as: if a is an instance of Eq, then [a] is also an instance of Eq. Note that this applies repeatedly as well, e.g., [[[Int]]] 27

40 Parameterised instances 2 By giving a single definition we can make all lists an instance of Eq: instance Eq a => Eq [a] where [ ] == [ ] = True [ ] == (y : ys) = False (x : xs) == [ ] = False (x : xs) == (y : ys) = x == y && xs == ys We have a single definition covering an infinite number of instances. x == y compares two elements (Eq a proves that we can do this) xs == ys is a recursive call to the function being defined 27

41 Another example 2 The Prelude defines a lexicographic ordering between lists: instance Ord a => Ord [a] where [ ] <= ys = True (x : xs) <= [ ] = False (x : xs) <= (y : ys) = x < y (x == y && xs <= ys) 28

42 More than one instance parameter 2 Instances can specify several preconditions (parameters). We use it to define equality for tuples: instance (Eq a, Eq b) => Eq (a, b) where (x, y) == (u, v) = x == u && y == v Elements of type (a, b) can be compared provided a and b can be compared, i.e. are instances of Eq. 29

43 Attention! 2 The reserved symbol => can be used in types, in instance-declarations and in class-declarations: f :: Num a => a > a is a type-declaration: f is a function with type a > a provided a is a type in the class Num 30

44 Attention! 2 The reserved symbol => can be used in types, in instance-declarations and in class-declarations: f :: Num a => a > a is a type-declaration: f is a function with type a > a provided a is a type in the class Num instance Eq a => Eq [a] is an instance-declaration: [a] is an instance of Eq provided a is 30

45 Attention! 2 The reserved symbol => can be used in types, in instance-declarations and in class-declarations: f :: Num a => a > a is a type-declaration: f is a function with type a > a provided a is a type in the class Num instance Eq a => Eq [a] is an instance-declaration: [a] is an instance of Eq provided a is class Eq a => Ord a is a class-declaration: all instances of the new class Ord have to be an instance of Eq too 30

46 Attention! 2 The reserved symbol => can be used in types, in instance-declarations and in class-declarations: f :: Num a => a > a is a type-declaration: f is a function with type a > a provided a is a type in the class Num instance Eq a => Eq [a] is an instance-declaration: [a] is an instance of Eq provided a is class Eq a => Ord a is a class-declaration: all instances of the new class Ord have to be an instance of Eq too The common theme is that before the => you write an assumption, or pre-condition 30

47 3. More standard classes 31

48 Standard classes 3 The prelude defines the following classes: Eq, the class of type which can be compared for equality; Ord, the class of types which have an ordering relation; Num, the class of types with have numeric properties; Enum, the class of types which can be enumerated; Ix, the class of types which can be used as an array index; Read and Show, the classes of types which have an external representation. 32

49 Show 3 Types which have external (i.e. String representations) are instances of Show show :: Show a => a > String 33

50 Show 3 Types which have external (i.e. String representations) are instances of Show show :: Show a => a > String All elementary types and composed types, such as lists and tuples, are instance of Show. 33

51 Show 3 Types which have external (i.e. String representations) are instances of Show show :: Show a => a > String All elementary types and composed types, such as lists and tuples, are instance of Show. Having show helps the interpreter decide how to display answers to you. So make sure you make every datatype an instance of Show! 33

52 All those instances: use deriving 3 Implementing show for every datatype bores quickly. You can let Haskell derive show (and other instances besides) when you define a new datatype: data Person = APerson String String Int deriving (Eq, Show, Read) generates sensible defaults for comparing, printing and reading Person values. If they are not what you want, do not derive them but write your own instances. 34

53 Enum 3 Enum is defined as: class Ord a => Enum a where enumfrom :: a > [a] enumfromthen :: a > a > [a] enumfromto :: a > a > [a] enumfromthento :: a > a > a > [a] 35

54 Use of Enum 3 Example uses: enumfrom 4 = [4, 5, 6, 7, 8,... enumfromthen 4 6 = [4, 6, 8,... enumfromto c f = [ c, d, e, f ] enumfromthento = [1.0, 1.5, 2.0, 2.5, 3.0] 36

55 Use of Enum 3 Example uses: enumfrom 4 = [4, 5, 6, 7, 8,... enumfromthen 4 6 = [4, 6, 8,... enumfromto c f = [ c, d, e, f ] enumfromthento = [1.0, 1.5, 2.0, 2.5, 3.0] The functions are used to desugar the list notations [x..], [x, y..], [x.. y] and [x, y.. z] 36

56 Enum Int 3 instance Enum Int where enumfrom i = iterate (1+) i enumfromthen i j = iterate ((j i)+) i 37

57 Default definitions for enumfromto and enumfromthento 3 class Ord a => Enum a where... enumfromto i j = takewhile (j >=) (enumfrom i) enumfromthento i i j i > i = takewhile (j >=) (enumfromthen i i ) otherwise = takewhile (j <=) (enumfromthen i i ) 38

58 Default definitions for enumfromto and enumfromthento 3 class Ord a => Enum a where... enumfromto i j = takewhile (j >=) (enumfrom i) enumfromthento i i j i > i = takewhile (j >=) (enumfromthen i i ) otherwise = takewhile (j <=) (enumfromthen i i ) This explains why instances of Enum have to be instances of Ord too. 38

59 The class Functor 3 The function map :: (a > b) > [a] > [b] is generalised in the Prelude to: class Functor f where fmap :: (a > b) > f a > f b This captures the pattern that values of type f a somehow contain values of type a, which can be converted to values of type b. 39

60 4. Overloaded numeric constants 40

61 How Haskell deals with constants 4 The class mechanism allows different versions of (+) to co-exist. 41

62 How Haskell deals with constants 4 The class mechanism allows different versions of (+) to co-exist. Thus far constants cannot co-exist, and we have to write: Int: 3 Float: 3.0 Rational: Rat (3, 1) Complex: Comp (3.0, 0.0) 41

63 A slight snag 4 If we define half = Rat (1, 2), we cannot write: 3 half because half has type Rational, whereas 3 has type Int. 42

64 Num revisited 4 To solve this problem the class Num contains one more function: frominteger. class Num a where (+), ( ), ( ), (/) :: a > a > a negate :: a > a frominteger :: Integer > a 43

65 Num revisited 4 To solve this problem the class Num contains one more function: frominteger. class Num a where (+), ( ), ( ), (/) :: a > a > a negate :: a > a frominteger :: Integer > a For each instance of Num we thus have to specify how an Integer value can be converted to an a value. Integer is the type of infinite precision integers, Int the type of finite precision integers. 43

66 For our own instances of Num... 4 we define our own specific conversion function: instance Num Rational where... frominteger n = Rat (frominteger n, 1) 44

67 For our own instances of Num... 4 we define our own specific conversion function: instance Num Rational where... frominteger n = Rat (frominteger n, 1) This means the symbol 3 is considered to be of type 3 :: Num a => a leaving the choice open until the context tells us what a should be. If a Rational is needed, frominteger converts it to the right rational. 44

68 5. Problems with type classes 45

69 Problem 1: Cannot derive instance 5 You get this error message when you need (implicitly) an instance for a type but you did not declare one:? (1,2,3) == (4,5,6) ERROR: Cannot derive instance in expression *** Expression : (1,2,3) == (4,5,6) *** Required instance : Eq (Int,Int,Int) 46

70 Problem 1: Cannot derive instance 5 You get this error message when you need (implicitly) an instance for a type but you did not declare one:? (1,2,3) == (4,5,6) ERROR: Cannot derive instance in expression *** Expression : (1,2,3) == (4,5,6) *** Required instance : Eq (Int,Int,Int) Here the standard prelude does not contain an instance declaration of Eq for triples. GHC is more permissive however. 46

71 Problem 1: Cannot derive instance 5 You get this error message when you need (implicitly) an instance for a type but you did not declare one:? (1,2,3) == (4,5,6) ERROR: Cannot derive instance in expression *** Expression : (1,2,3) == (4,5,6) *** Required instance : Eq (Int,Int,Int) Here the standard prelude does not contain an instance declaration of Eq for triples. GHC is more permissive however. The solution lies in adding the missing instance declaration. 46

72 ... continued... 5 You also get this error message if you try to compare functions, since function types are not instances of Eq:? tail == drop 1 ERROR: Cannot derive instance in expression *** Expression : tail == drop 1 *** Required instance : Eq ([a]->[a]) But here you do not expect to be able to provide a sensible instance, but instead you may want to pass a value to each of the functions and compare the results: \ xs > tail xs == drop 1 xs 47

73 Problem 2: overlapping instances 5 Another problem arises if an instance declaration is a special case of a more general case. 48

74 Problem 2: overlapping instances 5 Another problem arises if an instance declaration is a special case of a more general case. The Prelude defines tuples as an instance of Eq: instance (Eq a, Eq b) => Eq (a, b) where (x, y) == (u, v) = x == u && y == v 48

75 Problem 2: overlapping instances 5 Another problem arises if an instance declaration is a special case of a more general case. The Prelude defines tuples as an instance of Eq: instance (Eq a, Eq b) => Eq (a, b) where (x, y) == (u, v) = x == u && y == v We now try define rational numbers as a tuple, and provide an instance for this case: type Rational = (Int, Int) instance Eq Rational where (x, y) == (u, v) = x v == u y 48

76 ... continued... 5 For (1, 2) == (2, 4) it is now no longer possible to decide which definition for == to take. 49

77 ... continued... 5 For (1, 2) == (2, 4) it is now no longer possible to decide which definition for == to take. Hence the compiler reports: ERROR "file" (line 12): Overlapping instances for class "Eq" *** This instance : Eq (Int,Int) *** Overlaps with : Eq (a,a) *** Common instance : Eq (Int,Int) 49

78 ... continued... 5 For (1, 2) == (2, 4) it is now no longer possible to decide which definition for == to take. Hence the compiler reports: ERROR "file" (line 12): Overlapping instances for class "Eq" *** This instance : Eq (Int,Int) *** Overlaps with : Eq (a,a) *** Common instance : Eq (Int,Int) This problem can be solved here by defining: data Rational = Rat (Int, Int) 49

79 Problem 3: Unresolved overloading 5 Sometimes the compiler has insufficient information available to decide which instance to take:? frominteger 1 + frominteger 2 ERROR: Unresolved overloading *** type : Num a => a 50

80 Problem 3: Unresolved overloading 5 Sometimes the compiler has insufficient information available to decide which instance to take:? frominteger 1 + frominteger 2 ERROR: Unresolved overloading *** type : Num a => a For frominteger we can take the Int version or the Float version (or another). 50

81 Problem 3: Unresolved overloading 5 Sometimes the compiler has insufficient information available to decide which instance to take:? frominteger 1 + frominteger 2 ERROR: Unresolved overloading *** type : Num a => a For frominteger we can take the Int version or the Float version (or another). Since this is confusing the system will default to Int in such cases. 50

82 How to repair 5 Usually such problems can be solved by providing a type annotation:? (frominteger 1 + frominteger 2) :: Int 3 51

83 Problem 4: Ambiguity 5 show :: Show a => a > String read :: Read a => String > a f x = show (read x) No instance for (Show a0) arising from a use of show The type variable a0 is ambiguous Possible fix: add a type signature that fixes these type variable(s) No instance for (Read a0) arising from a use of read The type variable a0 is ambiguous Possible fix: add a type signature that fixes these type variable(s) 52 What is the (intermediate) type of read x that is passed to show?