Recursion and Induction: Tuples; Types; Lists

Greg Plaxton Theory in Programming Practice, Spring 2004 Department of Computer Science University of Texas at Austin Tuples

• The tuple is Haskell’s version of a record

• Any nonnegative number of data items (possibly of different types) can be combined together into a tuple

• Syntax: A tuple is surrounded by parentheses; the data items within the tuple are separated by commas

• Example: (3, 5, "foo", True)

• Of course, a component of a tuple can itself be a tuple – Example: (3, (5, "bar", ()), "foo", (True))

Theory in Programming Practice, Plaxton, Spring 2004 Tuples: The Special Case of a Singleton

• Note that Haskell uses parentheses for forming tuples and also for enforcing a particular order of evaluation within an expression

• Any expression x is equivalent to the singleton tuple with first (and only) component x – For example, the expressions "foo", ("foo"), and (("foo")) are all equivalent

Theory in Programming Practice, Plaxton, Spring 2004 Tuples: The Special Case of a Pair

• A tuple with two components is called a pair

• The predefined functions fst and snd are applicable to pairs, and return the first and second components of the pair, respectively – Example: fst ((1, 2, 3), True) evaluates to (1, 2, 3)

Theory in Programming Practice, Plaxton, Spring 2004 Tuples: Fibonacci Revisited

• In an earlier lecture we presented the following highly inefficient recursive program for computing the Fibonacci numbers fib 0 = 0 fib 1 = 1 fib (n + 2) = (fib n) + (fib (n + 1))

Theory in Programming Practice, Plaxton, Spring 2004 Tuples: A More Efficient Fibonacci Program

• The following function fibpair provides the basis for a more efficient implementation of fib fibpair 0 = (0,1) fibpair n = (y, x + y) where (x, y) = fibpair (n - 1)

• We can then define fib as follows fib 0 = 0 fib n = snd (fibpair (n - 1))

Theory in Programming Practice, Plaxton, Spring 2004 Tuples: A Fundamental Theorem of Number Theory

• For any pair of positive integers m and n, there exist integers a and b such that a · m + b · n = gcd(m, n)

• Exercises: – Prove the above result by induction on pairs of positive integers (m, n) – Prove the above result by induction on m + n – Write a Haskell program which, given a pair of positive integers (m, n), computes a pair (a, b) satisfying the above equation

Theory in Programming Practice, Plaxton, Spring 2004 Types

• Every Haskell expression has a type – The expression ’a’ has type Char – The expression "foo" has type [Char], which denotes a list of Char; we’ll discuss lists in greater detail later – The expression "(’a’, True)" has type (Char, Bool) – The function chr has type Int -> Char; we’ll discuss function types in greater detail on the next slide

• For the most part the types are inferred by the type system, rather than being explicitly specified by the programmer

• You can ask the hugs interpreter to specify the type of any expression by typing :t followed by the expression

Theory in Programming Practice, Plaxton, Spring 2004 Types: Functions

• Each function has a type, namely, the types of its arguments in order followed by the type of the result, all separated by ->

• Example: Suppose we define the functions imply p q = not p || q digit c = (’0’ <= c) && (c <= ’9’)

• We can then ask hugs to tell us the types of these functions Main> :t imply imply :: Bool -> Bool -> Bool Main> :t digit digit :: Char -> Bool

Theory in Programming Practice, Plaxton, Spring 2004 Types: Capitalization Rule

• Type names are capitalized

• The name of a function or parameter is not capitalized

Theory in Programming Practice, Plaxton, Spring 2004 Types: Polymorphism

• A polymorphic function can accept and produce data of many different types

• Haskell allows us to write functions whose arguments can be of any type, or any type that satisfies some constraints

Theory in Programming Practice, Plaxton, Spring 2004 Types: Polymorphism Examples

• Consider the following functions identity x = x exch (x,y) = (y,x) eqpair (x,y) = x == y

• Let’s ask hugs to tell us the type of each of these functions? Main> :t identity identity :: a -> a Main> :t exch exch :: (a,b) -> (b,a) Main> :t eqpair eqpair :: Eq a => (a,a) -> Bool

Theory in Programming Practice, Plaxton, Spring 2004 Types: Another Polymorphism Example

• Consider a function that sorts the two components of a pair. sortpair (x,y) | x <= y = (x,y) | x > y = (y,x)

• The type of sortpair is Main> :t sortpair sortpair :: Ord a => (a,a) -> (a,a)

Theory in Programming Practice, Plaxton, Spring 2004 Type Classes

• Haskell has an extensive type system which we only touch upon in this course

• A type class in Haskell represents a set of types, each of which has a certain function (or set of functions) defined on it – The Eq type class consists of all types on which an equality operation is defined – The Ord type class consists of all types on which an order operation is defined – The Num type class consists of all types on which typical arithmetic operations (+, *, et cetera) are defined

• Type classes in functional programming are analogous to classes in in object-oriented programming, except that a type class does not have any associated data

Theory in Programming Practice, Plaxton, Spring 2004 Type Violations

• Since the interpreter can infer the type of each expression, it can automatically detect type errors Main> digit "foo" ERROR - Type error in application *** Expression : digit "foo" *** Term : "foo" *** Type : String *** Does not match : Char

Main> digit 9 ERROR - Illegal Haskell 98 class constraint in inferred type *** Expression : digit 9 *** Type : Num Char => Bool

Theory in Programming Practice, Plaxton, Spring 2004 Lists

• A list is like a tuple but all of the elements of a list are required to be of the same type

• Square brackets are used to denote a list (as opposed to parentheses for tuples)

• Of course it is possible to have a list of lists, list of tuples, tuple of lists, list of lists of lists, et cetera

• Example: The expression [(3, 5), (3,8), (3, 5)] denotes a list of pairs

• Example: The expression [[2], 3, 5, 7] is invalid because the elements are not all of the same type

• Example: The expression [] denotes the empty list

Theory in Programming Practice, Plaxton, Spring 2004 Lists: The Type of a List

Main> :t [True] [True] :: [Bool] Main> :t [True, False, True, False] [True,False,True,False] :: [Bool] Main> :t [[2],[3],[5],[7]] [[2],[3],[5],[7]] :: Num a => [[a]] Main> :t [(3,5), (3,8), (3,5), (3,7)] [(3,5),(3,8),(3,5),(3,7)] :: (Num a, Num b) => [(a,b)] Main> :t [[(3,5), (3,8)], [(3,5), (3,7), (2,9)]] [[(3,5),(3,8)],[(3,5),(3,7),(2,9)]] :: (Num a, Num b) => [[(b,a)]] Main> :t [’a’,’b’,’c’] [’a’,’b’,’c’] :: [Char]

Theory in Programming Practice, Plaxton, Spring 2004 Lists: The Cons Constructor “:”

• The cons operator is used to construct a new list from an existing one by prepending an additional element

• The symbol “:”, pronounced “cons”, is used to denote this operator

• The expression x:xs denotes the list formed by prepending the element x to the list xs

Theory in Programming Practice, Plaxton, Spring 2004 Lists: Cons Examples

Main> 3: [2,1] [3,2,1] Main> 3: [] [3] Main> 1: (2: (3: [])) [1,2,3] Main> ’j’: "misra" "jmisra" Main> "j": "misra" ERROR - Type error in application *** Expression : "j" : "misra" *** Term : "j" *** Type : String *** Does not match : Char

Theory in Programming Practice, Plaxton, Spring 2004 Lists: Pattern Matching

• It is common to define a recursive function on lists by specifying the value explicitly for the empty list, and then using an inductive rule for nonempty lists

• Here is a function for computing the number of elements in a list len [] = 0 len (x:xs) = 1 + (len xs)

Theory in Programming Practice, Plaxton, Spring 2004 Lists: Sum, Product, Maximum

• Here are recursive programs for computing the sum, product, and maximum of the elements of a list suml [] = 0 suml (x:xs) = x + (suml xs)

multl [] = 1 multl (x:xs) = x * (multl xs)

maxl [x] = x maxl (x:xs) = max x (maxl xs)

Theory in Programming Practice, Plaxton, Spring 2004