Introduction to Programming: Lecture 10

Transcription

1 Introduction to Programming: Lecture 10 K Narayan Kumar Chennai Mathematical Institute 10 Sep 2012

2 Organizing functions as Modules Organize functions into modules.

3 Organizing functions as Modules Organize functions into modules. Each module contains functions that are related to each other.

4 Sorting Module The name of the file must match the name of the module

5 Sorting Module The name of the file must match the name of the module module SortingFns where insert :: Ord a => a -> [a] -> [a] insert x [] = isort :: Ord a => a -> [a] -> [a]

6 Sorting Module The name of the file must match the name of the module module SortingFns where insert :: Ord a => a -> [a] -> [a] insert x [] = isort :: Ord a => a -> [a] -> [a] To invoke functions from a module it must be imported import SortingFns isort [3,4,1,2,5]

7 Modules: Hiding some functions Helper functions such as insert, merge

8 Modules: Hiding some functions Helper functions such as insert, merge... should not be revealed to the user

9 Modules: Hiding some functions Helper functions such as insert, merge... should not be revealed to the user Clearly separates functionality from details of implementation.

10 Modules: Hiding some functions Helper functions such as insert, merge... should not be revealed to the user Clearly separates functionality from details of implementation. Allows the modification of the implementation without affecting other code.

11 Modules: Hiding some functions Helper functions such as insert, merge... should not be revealed to the user Clearly separates functionality from details of implementation. Allows the modification of the implementation without affecting other code. The set of functions revealed constitutes the interface of that module.

12 Modules: Hiding some functions module SortingFns (isort,mergesort) where insert :: Ord a => a -> [a] -> [a] insert x [] = isort :: Ord a => a -> [a] -> [a]

13 Modules: Hiding some functions module SortingFns (isort,mergesort) where insert :: Ord a => a -> [a] -> [a] insert x [] = isort :: Ord a => a -> [a] -> [a] Used as before

14 Modules: Hiding some functions module SortingFns (isort,mergesort) where insert :: Ord a => a -> [a] -> [a] insert x [] = isort :: Ord a => a -> [a] -> [a] Used as before import SortingFns isort [3,4,1,2,5]

15 Type-classes : Putting types into classes Type classes such as Num, Eq, Ord,... are defined in the Prelude.

16 Type-classes : Putting types into classes Type classes such as Num, Eq, Ord,... are defined in the Prelude. How to place a type in a typeclass such as Eq or Ord?

17 Type-classes : Putting types into classes Type classes such as Num, Eq, Ord,... are defined in the Prelude. How to place a type in a typeclass such as Eq or Ord? Ord requires that definitions be provided for the functions <=, <, >=, > data MLEntry = ME String Int deriving Eq First define functions that could act as <= etc. lt (ME s1 i1) (ME s2 i2) = i1 < i2 le (ME s1 i1) (ME s2 i2) = i1 <= i2...

18 Putting types into classes... Here is how we place MLEntry in Ord instance Ord MLEntry where (<) = lt (<=) = le (>) = gt (>=) = ge Now we can use <=, >=,.. as usual *Main> ME "Hendrix" 12 <= ME "Clapton" 16 True *Main> ME "Hendrix" 12 <= ME "Clapton" 8 False

19 User Defined Type-classes Type classes are defined using the class keyword

20 User Defined Type-classes Type classes are defined using the class keyword class (Sortable a) where leq :: a -> a -> Bool lt :: a -> a -> Bool geq :: a -> a -> Bool gt :: a -> a -> Bool

21 User Defined Type-classes Type classes are defined using the class keyword class (Sortable a) where leq :: a -> a -> Bool lt :: a -> a -> Bool geq :: a -> a -> Bool gt :: a -> a -> Bool A type belongs to a type-class if it supports these four functions.

22 User Defined Type-classes Type classes are defined using the class keyword class (Sortable a) where leq :: a -> a -> Bool lt :: a -> a -> Bool geq :: a -> a -> Bool gt :: a -> a -> Bool A type belongs to a type-class if it supports these four functions. The functions demanded by a type-class are called methods

23 Placing a type in type-class The keyword instance is used to place a type in a type-class. class Sortable a where leq :: a -> a -> Bool lt :: a -> a -> Bool geq :: a -> a -> Bool gt :: a -> a -> Bool

24 Placing a type in type-class The keyword instance is used to place a type in a type-class. class Sortable a where leq :: a -> a -> Bool lt :: a -> a -> Bool geq :: a -> a -> Bool gt :: a -> a -> Bool We may place Int in this class by declaring instance Sortable Int where leq = (<=) lt = (<) geq = (>=) gt = (>)

25 The definitions need not be meaningful class Sortable a where leq :: a -> a -> Bool lt :: a -> a -> Bool geq :: a -> a -> Bool gt :: a -> a -> Bool

26 The definitions need not be meaningful class Sortable a where leq :: a -> a -> Bool lt :: a -> a -> Bool geq :: a -> a -> Bool gt :: a -> a -> Bool We may also place Int in this class by declaring instance Sortable Int where leq = False lt = False geq = True gt = True

27 Defining type classes...

28 Defining type classes... Every sortable class needs to have equality defined.

29 Defining type classes... Every sortable class needs to have equality defined. class Eq a => Sortable a where lt :: a -> a -> Bool gt :: a -> a -> Bool geq :: a -> a -> Bool leq :: a -> a -> Bool

30 Defining type classes... Every sortable class needs to have equality defined. class Eq a => Sortable a where lt :: a -> a -> Bool gt :: a -> a -> Bool geq :: a -> a -> Bool leq :: a -> a -> Bool Restricts the type class Sortable only to classes that have equality defined on them.

31 Defining type classes...

32 Defining type classes... We may also provide definitions for some of the functions.

33 Defining type classes... We may also provide definitions for some of the functions. class Eq a => Sortable a where lt :: a -> a -> Bool gt :: a -> a -> Bool geq :: a -> a -> Bool leq :: a -> a -> Bool geq x y = (x == y) (gt x y) leq x y = (x == y) (lt x y)

34 Defining type classes... We may also provide definitions for some of the functions. class Eq a => Sortable a where lt :: a -> a -> Bool gt :: a -> a -> Bool geq :: a -> a -> Bool leq :: a -> a -> Bool geq x y = (x == y) (gt x y) leq x y = (x == y) (lt x y) Saves us some work in defining an instance.

35 Defining type classes... We may also provide definitions for some of the functions. class Eq a => Sortable a where lt :: a -> a -> Bool gt :: a -> a -> Bool geq :: a -> a -> Bool leq :: a -> a -> Bool geq x y = (x == y) (gt x y) leq x y = (x == y) (lt x y) Saves us some work in defining an instance. instance Sortable Int where lt x y = (x < y) gt x y = (x > y)

36 Defining type classes... We may also provide definitions for some of the functions. class Eq a => Sortable a where lt :: a -> a -> Bool gt :: a -> a -> Bool geq :: a -> a -> Bool leq :: a -> a -> Bool geq x y = (x == y) (gt x y) leq x y = (x == y) (lt x y) Saves us some work in defining an instance. instance Sortable Int where lt x y = (x < y) gt x y = (x > y) The default definitions are used only if an explicit definition is not provided.

37 Choice of functions to define We can even offer default definitions for all functions! class Eq a => Sortable a where lt :: a -> a -> Bool gt :: a -> a -> Bool geq :: a -> a -> Bool leq :: a -> a -> Bool gt x y = (x /= y) && not (lt x y) lt x y = (x /= y) && not (gt x y) geq x y = (x == y) (gt x y) leq x y = (x == y) (lt x y)

38 Choice of functions to define We can even offer default definitions for all functions! class Eq a => Sortable a where lt :: a -> a -> Bool gt :: a -> a -> Bool geq :: a -> a -> Bool leq :: a -> a -> Bool gt x y = (x /= y) && not (lt x y) lt x y = (x /= y) && not (gt x y) geq x y = (x == y) (gt x y) leq x y = (x == y) (lt x y) Allows us to define instances in many different ways. instance Sortable Int where gt x y = (x > y) or as instance Sortable Int where lt x y = (x < y)

39 Back to MLEntry To put a type in Ord, assuming it is in Eq, defining one function is sufficient.

40 Back to MLEntry To put a type in Ord, assuming it is in Eq, defining one function is sufficient. instance Ord MLEntry where (<=) = leq would suffice.

41 Back to MLEntry To put a type in Ord, assuming it is in Eq, defining one function is sufficient. instance Ord MLEntry where (<=) = leq would suffice. Actually Ord requires functions <=, >=, <, >, max, min and compare

42 Back to MLEntry To put a type in Ord, assuming it is in Eq, defining one function is sufficient. instance Ord MLEntry where (<=) = leq would suffice. Actually Ord requires functions <=, >=, <, >, max, min and compare Defining one of compare and <= is sufficient.

43 An Example We show how to place the type a -> b in Num whenever b is in Num.

44 An Example We show how to place the type a -> b in Num whenever b is in Num. class (Eq a, Show a) => Num a where (+), (-), (*) :: a -> a -> a negate :: a -> a abs, signum :: a -> a frominteger :: Integer -> a -- Minimal complete definition: -- All, except negate or (-) x - y = x + negate y negate x = 0 - x

45 An Example We show how to place the type a -> b in Num whenever b is in Num. class (Eq a, Show a) => Num a where (+), (-), (*) :: a -> a -> a negate :: a -> a abs, signum :: a -> a frominteger :: Integer -> a -- Minimal complete definition: -- All, except negate or (-) x - y = x + negate y negate x = 0 - x The obvious way to do define arithmetic operators on the functions space..

46 An Example We show how to place the type a -> b in Num whenever b is in Num. class (Eq a, Show a) => Num a where (+), (-), (*) :: a -> a -> a negate :: a -> a abs, signum :: a -> a frominteger :: Integer -> a -- Minimal complete definition: -- All, except negate or (-) x - y = x + negate y negate x = 0 - x The obvious way to do define arithmetic operators on the functions space.. (f + g) x = (f x) + (g x) and so on.

47 An Example We show how to place the type a -> b in Num whenever b is in Num. class (Eq a, Show a) => Num a where (+), (-), (*) :: a -> a -> a negate :: a -> a abs, signum :: a -> a frominteger :: Integer -> a -- Minimal complete definition: -- All, except negate or (-) x - y = x + negate y negate x = 0 - x The obvious way to do define arithmetic operators on the functions space.. (f + g) x = (f x) + (g x) and so on. How about frominteger?

48 A defintion for frominteger Send each integer i to the constant function that returns the value i.

49 A defintion for frominteger Send each integer i to the constant function that returns the value i. Thus f + frominteger 5 will return (f x)+5 at each point x.

50 A defintion for frominteger Send each integer i to the constant function that returns the value i. Thus f + frominteger 5 will return (f x)+5 at each point x. frominteger n = (f n) where f n x = frominteger n

51 Membership in Eq, Ord and Show instance Num b => Eq (a->b) where _ == _ = False instance Num b => Ord (a->b) where _ < _ = False instance Num b => Show (a->n) where show x = "No way you can print a function"

52 Membership in Num lift op f g x = op (f x) (g x) instance Num b => Num (a->b) where (+) = lift (+) (*) = lift (*) (-) = lift (-) abs f x = abs (f x) signum f x = signum (f x) frominteger n = (f n) where f n x = frominteger n