Composite Datatypes Lists and Tuples

Transcription

1 Composite Datatypes Lists and Tuples CS190 Functional Programming Techniques Dr Hans Georg Schaathun University of Surrey Autumn 2008 Week 4 Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 1 / 35

2 Outline 1 Introduction 2 Tuples 3 Lists 4 Polymorphism 5 Strings 6 Conclusion Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 2 / 35

3 This session After this session, you should be able to handle composite data types in Haskell defining the types defining functions on the types using standard Prelude functions Reference: Thompson, Chapter 5 Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 3 / 35

4 Introduction Shopping basket as an example A basket contains many items Each item comprises a description and a quantity Sample items: ( "Salt (1lb)", 3 ) ( "Sugar (1kg)", 5 ) Sample Shopping Basket: [( "Salt (1lb)", 3 ), ( "Sugar (1kg)", 5 ), ( "Orange", 12 ) ] Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 4 / 35

5 Introduction Tuples versus Lists The items are tuples: (String, Int) Fixed number of entries (2) Combining different data types (String and Int) The basket is a list: [ (String, Int) ] Variable number of items Same data type (String,Int) Any data type can be used to define tuples and strings Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 5 / 35

6 Introduction Defining data types We can define our own data types: type Item = (String,Int) type Basket = [Item] This establishes synonyms for common data types synonyms makes code more intuitive and readable can be used interchangably (when readability is not an issue) All type identifiers have to start with a Capital The built-in type String is defined as type String = [Char] i.e. a String is a special case of lists Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 6 / 35

7 Introduction Defining data types We can define our own data types: type Item = (String,Int) type Basket = [Item] This establishes synonyms for common data types synonyms makes code more intuitive and readable can be used interchangably (when readability is not an issue) All type identifiers have to start with a Capital The built-in type String is defined as type String = [Char] i.e. a String is a special case of lists Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 6 / 35

8 Introduction Defining data types We can define our own data types: type Item = (String,Int) type Basket = [Item] This establishes synonyms for common data types synonyms makes code more intuitive and readable can be used interchangably (when readability is not an issue) All type identifiers have to start with a Capital The built-in type String is defined as type String = [Char] i.e. a String is a special case of lists Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 6 / 35

9 Outline Tuples Uses of tuples 1 Introduction 2 Tuples Uses of tuples Functions over tuples 3 Lists 4 Polymorphism 5 Strings 6 Conclusion Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 7 / 35

10 Other tuples Tuples Uses of tuples Tuples can have any number of items type Item = (String,Float,String) e.g. ("Oranges",3.5,"lbs")... or type Item = (String,String,Int,String,String) e.g. ("CS190", "Functional Programming", 15, "HGS", " Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 8 / 35

11 Tuples Uses of tuples Why do we use tuples? Related information should be bundled together For instance, a data base Person needs: name, address, date of birth etc. Library book needs: title, author, shelfmark, ISBN, etc. Represent each person/book by a tuple one variable identifies one person/book each piece of information is one component of the tuple Every person/book have the same components Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 9 / 35

12 Outline Tuples Functions over tuples 1 Introduction 2 Tuples Uses of tuples Functions over tuples 3 Lists 4 Polymorphism 5 Strings 6 Conclusion Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 10 / 35

13 Pattern matching A known example Tuples Functions over tuples factorial 0 = 1 factorial n = factorial (n-1) Several function definitions Different patterns for the arguments Haskell will use the first applicable pattern 1 0 is a literal, and matches only a numerical 0. 2 n is an identifier and matches any value Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 11 / 35

14 Tuple patterns Tuples Functions over tuples Introducing tuples, more complex patterns become possible itemtype :: Item -> String itemtype (x,_) = x (x,_) matches any pair x matches the first item _ matches anything but no identifier is assigned quantity :: Item -> Float quantity (_,x) = x Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 12 / 35

15 Tuple patterns Tuples Functions over tuples Introducing tuples, more complex patterns become possible itemtype :: Item -> String itemtype (x,_) = x (x,_) matches any pair x matches the first item _ matches anything but no identifier is assigned quantity :: Item -> Float quantity (_,x) = x Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 12 / 35

16 Tuples Functions over tuples Selector functions an example itemtype is a selector function extracts one of several items selector functions are often needed built-in selector functions fst (x,_) = x snd (_,y) = x Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 13 / 35

17 Tuples Pattern matching for readibility Functions over tuples Consider a function adding the components of a pair addpair :: (Int,Int) -> Int Selector functions can solve the problem addpair p = fst p + snd p Pattern matching tends to make it more readable addpair (x,y) = x + y Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 14 / 35

18 Tuples Pattern matching for readibility Functions over tuples Consider a function adding the components of a pair addpair :: (Int,Int) -> Int Selector functions can solve the problem addpair p = fst p + snd p Pattern matching tends to make it more readable addpair (x,y) = x + y Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 14 / 35

19 Tuples Pattern matching for readibility Functions over tuples Consider a function adding the components of a pair addpair :: (Int,Int) -> Int Selector functions can solve the problem addpair p = fst p + snd p Pattern matching tends to make it more readable addpair (x,y) = x + y Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 14 / 35

20 Outline Lists The power of lists 1 Introduction 2 Tuples 3 Lists The power of lists List comprehension Functions on lists 4 Polymorphism 5 Strings 6 Conclusion Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 15 / 35

21 Lists The power of lists The generality of lists For every type t there is a list type [t] Lists of Float: [Float] Lists of lists of Float: [[Float]] Lists of tuples: [(Float,[Float],Int)] Lists of functions: [ Int -> Int] Lists of functions on lists: [ [Int] -> Float ] There is no limit But each list type has one specific constituent type Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 16 / 35

22 Lists The power of lists The strength of functional programming Lists is at the heart of functional programming The strength is in the flexible functions possible on lists... that is... polymorphism to be explored later in this session higher-order functions for next week Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 17 / 35

23 Outline Lists List comprehension 1 Introduction 2 Tuples 3 Lists The power of lists List comprehension Functions on lists 4 Polymorphism 5 Strings 6 Conclusion Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 18 / 35

24 Lists List comprehension Systematic definition of large lists Large lists can be defined systematically similar to normal mathematical notation For instance [1..9] = [1,2,3,4,5,6,7,8,9] [2*x x<-[1..8] ] = [2,4,6,8,10,12,14,16] The latter example is known as list comprehension In maths notation it looks like {1... 9} {2x x {1... 8}} Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 19 / 35

25 Lists List comprehension Systematic definition of large lists Large lists can be defined systematically similar to normal mathematical notation For instance [1..9] = [1,2,3,4,5,6,7,8,9] [2*x x<-[1..8] ] = [2,4,6,8,10,12,14,16] The latter example is known as list comprehension In maths notation it looks like {1... 9} {2x x {1... 8}} Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 19 / 35

26 Lists List comprehension List comprehension ex = [1..8] [2*x x<-ex] List comprehension generates a list based on another list the variable x is called a generator The general form is [expression condition] expression is evaluated for every value of the generator(s) where the generator(s) have to satisfy the condition The simplest condition x ex (x<-ex) Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 20 / 35

27 Multiple generators Lists List comprehension Sometimes more than one generator is used suits = [ "Spades", "Hearts", "Diamonds", "Clubs" ] honours = [ "Ace", "King", "Queen", "Knave" ] goodcards = [ (x,y) x <- suits, y <- honours ] What does goodcards evaluate to? Main> goodcards [("Spades","Ace"),("Spades","King"),("Spades","Queen"), ("Spades","Knave"), ("Hearts","Ace"),("Hearts","King"), ("Hearts","Queen"),("Hearts","Knave"),("Diamonds","Ace"), ("Diamonds","King"),("Diamonds","Queen"),("Diamonds","Knave"), ("Clubs","Ace"),("Clubs","King"), ("Clubs","Queen"), ("Clubs","Knave")] Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 21 / 35

28 Multiple generators Lists List comprehension Sometimes more than one generator is used suits = [ "Spades", "Hearts", "Diamonds", "Clubs" ] honours = [ "Ace", "King", "Queen", "Knave" ] goodcards = [ (x,y) x <- suits, y <- honours ] What does goodcards evaluate to? Main> goodcards [("Spades","Ace"),("Spades","King"),("Spades","Queen"), ("Spades","Knave"), ("Hearts","Ace"),("Hearts","King"), ("Hearts","Queen"),("Hearts","Knave"),("Diamonds","Ace"), ("Diamonds","King"),("Diamonds","Queen"),("Diamonds","Knave"), ("Clubs","Ace"),("Clubs","King"), ("Clubs","Queen"), ("Clubs","Knave")] Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 21 / 35

29 Lists List comprehension Complex conditions Suppose we have a function iseven n = (n mod 2 == 0) which is True if and only if n is even ex = [2,5,8,12] [ 2*n n <- ex, iseven n, n > 3 ] now only even ns larger than 3 are used the result is 16,24 Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 22 / 35

30 Lists List comprehension Complex conditions Suppose we have a function iseven n = (n mod 2 == 0) which is True if and only if n is even ex = [2,5,8,12] [ 2*n n <- ex, iseven n, n > 3 ] now only even ns larger than 3 are used the result is 16,24 Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 22 / 35

31 Lists List comprehension Conditions with pattern matching Normal rules for pattern matching apply in list comprehension For instance addpairs :: [(Int,Int)] -> [Int] addpairs pl = [ x+y (x,y) <- pl ] addpairs [ (2,3), (2,5), (3,1) ] [ 2+3, 2+5, 3+1 ] = [5,7,4] Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 23 / 35

32 Outline Lists Functions on lists 1 Introduction 2 Tuples 3 Lists The power of lists List comprehension Functions on lists 4 Polymorphism 5 Strings 6 Conclusion Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 24 / 35

33 List patterns Simple patterns Lists Functions on lists Pattern matching applies to lists as to tuples ltest [0,a] = a ltest [0,a,b] = a + b ltest [a,_] = a... but such patterns dictate the list length Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 25 / 35

34 Lists Functions on lists List patterns Simple patterns The list constructor : can be used for patterns x:xs x is one element (the first) xs is the rest of the list Note that xs is one element shorter than x:xs this is the basis for simple recursion For instance, return the first non-zero element ltest (0:xs) = ltest xs ltest (x:xs) = x Is there a bug in the ltest code above? Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 26 / 35

35 Lists Functions on lists List patterns Simple patterns The list constructor : can be used for patterns x:xs x is one element (the first) xs is the rest of the list Note that xs is one element shorter than x:xs this is the basis for simple recursion For instance, return the first non-zero element ltest (0:xs) = ltest xs ltest (x:xs) = x Is there a bug in the ltest code above? Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 26 / 35

36 Lists Functions on lists List patterns Simple patterns The list constructor : can be used for patterns x:xs x is one element (the first) xs is the rest of the list Note that xs is one element shorter than x:xs this is the basis for simple recursion For instance, return the first non-zero element ltest (0:xs) = ltest xs ltest (x:xs) = x Is there a bug in the ltest code above? Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 26 / 35

37 Lists Functions on lists List patterns Simple patterns The list constructor : can be used for patterns x:xs x is one element (the first) xs is the rest of the list Note that xs is one element shorter than x:xs this is the basis for simple recursion For instance, return the first non-zero element ltest (0:xs) = ltest xs ltest (x:xs) = x Is there a bug in the ltest code above? Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 26 / 35

38 Outline Polymorphism Polymorphism 1 Introduction 2 Tuples 3 Lists 4 Polymorphism Polymorphism 5 Strings 6 Conclusion Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 27 / 35

39 Polymorphism Polymorphism Polymorphism polymporphism «has many shapes» Polymorphic functions apply to different types of data For instance the length of a list length :: [a] -> Int where a is a type variable i.e. a matches any type Or concatenation (++) :: [a] -> [a] -> [a] a is an arbitrary type but all three instances of a are the same type Polymorphism saves us the trouble of typing several similar definitions Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 28 / 35

40 For example Polymorphism Polymorphism The length function could be defined as length :: [a] -> Int length [] = 0 length (x:xs) = 1 + length xs This is an example of recursion over lists Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 29 / 35

41 For example Polymorphism Polymorphism The length function could be defined as length :: [a] -> Int length [] = 0 length (x:xs) = 1 + length xs This is an example of recursion over lists Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 29 / 35

42 Polymorphism Polymorphism Polymorphism versus Overloading Polymorphism and Overloading both allow same function name on different types However, there is a key difference Polymorphism has a single function definition applicable to several types Overloading allows different definitions for different types Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 30 / 35

43 Polymorphism Polymorphism Polymorphism versus Overloading Polymorphism and Overloading both allow same function name on different types However, there is a key difference Polymorphism has a single function definition applicable to several types Overloading allows different definitions for different types Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 30 / 35

44 Polymorphism Polymorphism Polymorphism versus Overloading Polymorphism and Overloading both allow same function name on different types However, there is a key difference Polymorphism has a single function definition applicable to several types Overloading allows different definitions for different types Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 30 / 35

45 Polymorphism Polymorphism Polymorphism versus Overloading Polymorphism and Overloading both allow same function name on different types However, there is a key difference Polymorphism has a single function definition applicable to several types Overloading allows different definitions for different types Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 30 / 35

46 Strings Strings A special case of lists String is a synonum for [Char] All polymorphic list functions apply to strings map, foldr, ++ Main> [ a, b, c ] "abc" Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 31 / 35

47 Special Characters Strings Special characters represented by escape sequences Newline \n Tab \t Quotes (\" \ ) Backslash \\ Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 32 / 35

48 Strings Printing Special characters Hugs displays the escape sequences Not the special characters Main> "Item\tQuantity\nApples\t4\nOranges\t12\n" "Item\tQuantity\nApples\t4\nOranges\t12\n" An I/O function is needed to get the proper display This is the putstr function Main> putstr "Item\tQuantity\nApples\t4\nOranges\t12\n Item Quantity Apples 4 Oranges 12 Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 33 / 35

49 Strings Printing Special characters Hugs displays the escape sequences Not the special characters Main> "Item\tQuantity\nApples\t4\nOranges\t12\n" "Item\tQuantity\nApples\t4\nOranges\t12\n" An I/O function is needed to get the proper display This is the putstr function Main> putstr "Item\tQuantity\nApples\t4\nOranges\t12\n Item Quantity Apples 4 Oranges 12 Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 33 / 35

50 Outline Conclusion Summary 1 Introduction 2 Tuples 3 Lists 4 Polymorphism 5 Strings 6 Conclusion Summary Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 34 / 35

51 Summary Conclusion Summary Much of the power of functional languages is the list capabilities Simple expressions to define lists List comprehension Simple techniques to define functions on lists Built-in map and foldr Recursion (next week) Dr Hans Georg Schaathun Composite Datatypes Lists and Tuples Autumn 2008 Week 4 35 / 35