1. 0 PROGRAMMING IN HASKELL Chapter 9 - Higher-Order Functions, Functional Parsers

2. Introduction 1 A function is called higher-order if it takes a function as an argument or returns a function as a result. twice :: (a  a)  a  a twice f x = f (f x) twice is higher-order because it takes a function as its first argument.

3. Why Are They Useful? 2 zCommon programming idioms can be encoded as functions within the language itself. zDomain specific languages can be defined as collections of higher-order functions. zAlgebraic properties of higher-order functions can be used to reason about programs.

4. The Map Function 3 The higher-order library function called map applies a function to every element of a list. map :: (a  b)  [a]  [b] For example: > map (+1) [1,3,5,7] [2,4,6,8]

5. 4 Alternatively, for the purposes of proofs, the map function can also be defined using recursion: The map function can be defined in a particularly simple manner using a list comprehension: map f xs = [f x | x  xs] map f [] = [] map f (x:xs) = f x : map f xs

6. The Filter Function 5 The higher-order library function filter selects every element from a list that satisfies a predicate. filter :: (a  Bool)  [a]  [a] For example: > filter even [1..10] [2,4,6,8,10]

7. 6 Alternatively, it can be defined using recursion: Filter can be defined using a list comprehension: filter p xs = [x | x  xs, p x] filter p [] = [] filter p (x:xs) | p x = x : filter p xs | otherwise = filter p xs

8. The Foldr Function 7 A number of functions on lists can be defined using the following simple pattern of recursion: f [] = v f (x:xs) = x  f xs f maps the empty list to some value v, and any non-empty list to some function  applied to its head and f of its tail.

9. 8 For example: sum [] = 0 sum (x:xs) = x + sum xs and [] = True and (x:xs) = x && and xs product [] = 1 product (x:xs) = x * product xs v = 0  = + v = 1  = * v = True  = &&

10. 9 The higher-order library function foldr (fold right) encapsulates this simple pattern of recursion, with the function  and the value v as arguments. For example: sum = foldr (+) 0 product = foldr (*) 1 or = foldr (||) False and = foldr (&&) True

11. 10 Foldr itself can be defined using recursion: foldr :: (a  b  b)  b  [a]  b foldr f v [] = v foldr f v (x:xs) = f x (foldr f v xs) However, it is best to think of foldr non-recursively, as simultaneously replacing each (:) in a list by a given function, and [] by a given value.

12. 11 sum [1,2,3] foldr (+) 0 [1,2,3] = foldr (+) 0 (1:(2:(3:[]))) = 1+(2+(3+0)) = 6 = For example: Replace each (:) by (+) and [] by 0.

13. 12 product [1,2,3] foldr (*) 1 [1,2,3] = foldr (*) 1 (1:(2:(3:[]))) = 1*(2*(3*1)) = 6 = For example: Replace each (:) by (*) and [] by 1.

14. Other Foldr Examples 13 Even though foldr encapsulates a simple pattern of recursion, it can be used to define many more functions than might first be expected. Recall the length function: length :: [a]  Int length [] = 0 length (_:xs) = 1 + length xs

15. 14 length [1,2,3] length (1:(2:(3:[]))) = 1+(1+(1+0)) = 3 = Hence, we have: length = foldr ( _ n  1+n) 0 Replace each (:) by _ n  1+n and [] by 0. For example:

16. 15 Now recall the reverse function: reverse [] = [] reverse (x:xs) = reverse xs ++ [x] reverse [1,2,3] reverse (1:(2:(3:[]))) = (([] ++ [3]) ++ [2]) ++ [1] = [3,2,1] = For example: Replace each (:) by x xs  xs ++ [x] and [] by [].

17. 16 Hence, we have: reverse = foldr ( x xs  xs ++ [x]) [] Finally, we note that the append function ( ++ ) has a particularly compact definition using foldr: (++ ys) = foldr (:) ys Replace each (:) by (:) and [] by ys.

18. Why Is Foldr Useful? 17 zSome recursive functions on lists, such as sum, are simpler to define using foldr. zProperties of functions defined using foldr can be proved using algebraic properties of foldr, such as fusion and the banana split rule. zAdvanced program optimisations can be simpler if foldr is used in place of explicit recursion.

19. Other Library Functions 18 The library function (.) returns the composition of two functions as a single function. (.) :: (b  c)  (a  b)  (a  c) f. g = x  f (g x) For example: odd :: Int  Bool odd = not. even

20. 19 The library function all decides if every element of a list satisfies a given predicate. all :: (a  Bool)  [a]  Bool all p xs = and [p x | x  xs] For example: > all even [2,4,6,8,10] True

21. 20 Dually, the library function any decides if at least one element of a list satisfies a predicate. any :: (a  Bool)  [a]  Bool any p xs = or [p x | x  xs] For example: > any isSpace "abc def" True

22. 21 The library function takeWhile selects elements from a list while a predicate holds of all the elements. takeWhile :: (a  Bool)  [a]  [a] takeWhile p [] = [] takeWhile p (x:xs) | p x = x : takeWhile p xs | otherwise = [] For example: > takeWhile isAlpha "abc def" "abc"

23. 22 Dually, the function dropWhile removes elements while a predicate holds of all the elements. dropWhile :: (a  Bool)  [a]  [a] dropWhile p [] = [] dropWhile p (x:xs) | p x = dropWhile p xs | otherwise = x:xs For example: > dropWhile isSpace " abc" "abc"

24. Exercises 23 (3)Redefine map f and filter p using foldr. (2) Express the comprehension [f x | x  xs, p x] using the functions map and filter. (1) What are higher-order functions that return functions as results better known as?

25. What is a Parser? 24 A parser is a program that analyses a piece of text to determine its syntactic structure. 2  3+4 means 4 + 2  32

26. Where Are They Used? 25 Almost every real life program uses some form of parser to pre-process its input. Haskell programs Shell scripts HTML documents Hugs Unix Explorer parses

27. The Parser Type 26 In a functional language such as Haskell, parsers can naturally be viewed as functions. type Parser = String  Tree A parser is a function that takes a string and returns some form of tree.

28. 27 However, a parser might not require all of its input string, so we also return any unused input: type Parser = String  (Tree,String) A string might be parsable in many ways, including none, so we generalize to a list of results: type Parser = String  [(Tree,String)]

29. 28 Finally, a parser might not always produce a tree, so we generalize to a value of any type: type Parser a = String  [(a,String)] Note: zFor simplicity, we will only consider parsers that either fail and return the empty list of results, or succeed and return a singleton list.

30. Basic Parsers 29 zThe parser item fails if the input is empty, and consumes the first character otherwise: item :: Parser Char item = inp  case inp of []  [] (x:xs)  [(x,xs)]

31. 30 zThe parser failure always fails: failure :: Parser a failure = inp  [] zThe parser return v always succeeds, returning the value v without consuming any input: return :: a  Parser a return v = inp  [(v,inp)]

32. 31 zThe parser p +++ q behaves as the parser p if it succeeds, and as the parser q otherwise: (+++) :: Parser a  Parser a  Parser a p +++ q = inp  case p inp of []  parse q inp [(v,out)]  [(v,out)] zThe function parse applies a parser to a string: parse :: Parser a  String  [(a,String)] parse p inp = p inp

33. Examples 32 % hugs Parsing > parse item "" [] > parse item "abc" [('a',"bc")] The behavior of the five parsing primitives can be illustrated with some simple examples:

34. 33 > parse failure "abc" [] > parse (return 1) "abc" [(1,"abc")] > parse (item +++ return 'd') "abc" [('a',"bc")] > parse (failure +++ return 'd') "abc" [('d',"abc")]

35. 34 Note: zThe library file Parsing is available on the web from the Programming in Haskell home page. zFor technical reasons, the first failure example actually gives an error concerning types, but this does not occur in non-trivial examples. zThe Parser type is a monad, a mathematical structure that has proved useful for modeling many different kinds of computations.

36. Sequencing 35 A sequence of parsers can be combined as a single composite parser using the keyword do. For example: p :: Parser (Char,Char) p = do x  item item y  item return (x,y)

37. 36 Note: zEach parser must begin in precisely the same column. That is, the layout rule applies. zThe values returned by intermediate parsers are discarded by default, but if required can be named using the  operator. zThe value returned by the last parser is the value returned by the sequence as a whole.

38. 37 zIf any parser in a sequence of parsers fails, then the sequence as a whole fails. For example: > parse p "abcdef" [((’a’,’c’),"def")] > parse p "ab" [] zThe do notation is not specific to the Parser type, but can be used with any monadic type.

39. Derived Primitives 38 sat :: (Char  Bool)  Parser Char sat p = do x  item if p x then return x else failure zParsing a character that satisfies a predicate:

40. 39 digit :: Parser Char digit = sat isDigit char :: Char  Parser Char char x = sat (x ==) zParsing a digit and specific characters: zApplying a parser zero or more times: many :: Parser a  Parser [a] many p = many1 p +++ return []

41. 40 many1 :: Parser a -> Parser [a] many1 p = do v  p vs  many p return (v:vs) zApplying a parser one or more times: zParsing a specific string of characters: string :: String  Parser String string [] = return [] string (x:xs) = do char x string xs return (x:xs)

42. Example 41 We can now define a parser that consumes a list of one or more digits from a string: p :: Parser String p = do char '[' d  digit ds  many (do char ',' digit) char ']' return (d:ds)

43. 42 For example: > parse p "[1,2,3,4]" [("1234","")] > parse p "[1,2,3,4" [] Note: zMore sophisticated parsing libraries can indicate and/or recover from errors in the input string.

44. Arithmetic Expressions 43 Consider a simple form of expressions built up from single digits using the operations of addition + and multiplication *, together with parentheses. We also assume that:  * and + associate to the right;  * has higher priority than +.

45. 44 Formally, the syntax of such expressions is defined by the following context free grammar: expr  term '+' expr  term term  factor '*' term  factor factor  digit  '(' expr ')‘ digit  '0'  '1'    '9'

46. 45 However, for reasons of efficiency, it is important to factorise the rules for expr and term: expr  term ('+' expr   ) term  factor ('*' term   ) Note:  The symbol  denotes the empty string.

47. 46 It is now easy to translate the grammar into a parser that evaluates expressions, by simply rewriting the grammar rules using the parsing primitives. That is, we have: expr :: Parser Int expr = do t  term do char '+' e  expr return (t + e) +++ return t

48. 47 factor :: Parser Int factor = do d  digit return (digitToInt d) +++ do char '(' e  expr char ')' return e term :: Parser Int term = do f  factor do char '*' t  term return (f * t) +++ return f

49. 48 Finally, if we define eval :: String  Int eval xs = fst (head (parse expr xs)) then we try out some examples: > eval "2*3+4" 10 > eval "2*(3+4)" 14

50. Exercises 49 (2) Extend the expression parser to allow the use of subtraction and division, based upon the following extensions to the grammar: expr  term ('+' expr  '-' expr   ) term  factor ('*' term  '/' term   ) (1) Why does factorising the expression grammar make the resulting parser more efficient?