1. Advanced Programming Languages Lecture 1 NCCU CS Dept. Fall 2005 Sept. 19, 2005

2. Topics Haskell, Part 1 Lambda Calculus Operational Semantics Denotational Semantics Polymorphism & Type Inference Haskell, Pat 2 (Type classes, …) Subtyping and OO Research Papers

3. Reading Materials Lecture Notes from Prof. Johan Glimming Haskell –Tutorial: A Gentle Introduction to Haskell SML lecture notes Other lecture notes Textbooks: –B. Pierce, Type Systems and Programming Languages, MIT Press, 2002 –Nielson’s, Semantics with Applications, Draft, 2005 Papers

4. Haskell-based Textbooks Simon Thompson. Haskell: The Craft of Functional Programming, Addison Wesley, 1999. Richard Bird. Introduction to Functional Programming Using Haskell, second edition, Prentice Hall Europe, 1998. Paul Hudak. The Haskell School of Expression, Cambridge University Press, 2000. H. C. Cunningham. Notes on Functional Programming with Gofer, Technical Report UMCIS-1995-01, University of Mississippi, Department of Computer and Information Science, Revised January 1997. http://www.cs.olemiss.edu/~hcc/reports/gofer_notes.pdf

5. Other FP Textbooks Of Interest Fethi Rabhi and Guy Lapalme. Algorithms: A Functional Approach, Addison Wesley, 1999. Chris Okasaki. Purely Functional Data Structures, Cambridge University Press, 1998.

6. Programming Language Paradigms Imperative languages –have implicit states –use commands to modify state –express how something is computed –include C, Pascal, Ada, … Declarative languages –have no implicit states –use expressions that are evaluated –express what is to be computed –have different underlying models functions: Lisp (Pure), ML, Haskell, …spreadsheets? SQL? relations (logic): Prolog (Pure), Parlog, …

7. Orderly Expressions and Disorderly Statements { x = 1; y = 2; z = 3 } x =3 * x + 2 * y + z y =5 * x – y + 2 * z Values of x and y depend upon order of execution of statements x represents different values in different contexts

13. Summary: Why Use Functional Programming? Referential transparency –symbol always represents the same value –Equational reasoning (equals can be substituted by equals) easy mathematical manipulation, parallel execution, etc. Expressive and concise notation Higher-order functions –take/return functions –powerful abstraction mechanisms Lazy evaluation –defer evaluation until result needed –new algorithmic approaches Polymorphic Type systems

14. Why Teach/Learn FP and Haskell? Introduces new problem solving techniques Improves ability to build and use higher-level procedural and data abstractions Helps instill a desire for elegance in design and implementation Increases comfort and skill in use of recursive programs and data structures Develops understanding of programming languages features such as type systems Introduces programs as mathematical objects in a natural way

15. Haskell: http://haskell.org/http://haskell.org/ Haskell is a general purpose, purely functional programming language. Started in 1987; current version Haskell 98 (2002 revised) –Yale Univ. & Glasgow Univ. –Chalmers Univ. (Sweden) Many free implementations: –Hugs 98, a popular Haskell interpreter (written in C) Derived from Gopher, by Mark Jones –GHC, the Glasgow Haskell Compiler –… Good course websites: –http://csit.nottingham.edu.my/~cmichael/Teaching/Feb05/G51FUN/ fun.htmlhttp://csit.nottingham.edu.my/~cmichael/Teaching/Feb05/G51FUN/ fun.html –http://www.cs.chalmers.se/Cs/Grundutb/Kurser/d1pt/d1pta/external.htmlhttp://www.cs.chalmers.se/Cs/Grundutb/Kurser/d1pt/d1pta/external.html

16. Haskell Timeline Sept 87: kick off Apr 90: Haskell 1.0 May 92: Haskell 1.2 (SIGPLAN Notices) (164pp) Aug 91: Haskell 1.1 (153pp) May 96: Haskell 1.3. Monadic I/O, separate library report Apr 97: Haskell 1.4 (213pp) Feb 99: Haskell 98 (240pp) Dec 02: Haskell 98 revised (260pp) The Book!

17. A Short Tour to Hugs

19. Definitions name :: type e.g.: size :: Int size = 12 - 3 Function definitions name :: t1 -> t2 -> … -> tk -> t function name types of type of result arguments e.g.: exOr :: Bool -> Bool -> Bool exOr x y = (x || y) && not (x && y) Definitions

26. Variable binders: x and y get their values from the argument

32. (Integer  Integer)  Integer  Integer

37. Technique: Accumulating parameter

40. “==“

46. Currying and Partial Evaluation add :: (Int,Int) -> Int add (x,y) = x + y ? add(3,4) => 7 ? add (3, ) => error add’ takes one argument and returns a function Takes advantage of Currying add' :: Int->(Int->Int) add' x y = x + y ? add’ 3 4 => 7 ? add’ 3 (add’ 3) :: Int -> Int (add’ 3) x = 3 + x ((+) 3)

48. Fold Right Abstract different binary operators to be applied foldr :: (a -> b -> b) -> b -> [a] -> b foldr f z [] = z -- binary op, identity, list foldr f z (x:xs) = f x (foldr f z xs) sumlist :: [Int] -> Int sumlist xs = foldr (+) 0 xs concat' :: [[a]] -> [a] concat' xss = foldr (++) [] xss

49. Using Partial Evaluation doublePos :: [Int] -> [Int] doublePos xs = map ((*) 2) (filter ((<) 0) xs) Using operator section notation doublePos xs = map (*2) (filter (0<) xs) Using list comprehension notation doublePos xs = [ 2*x | x <- xs, 0< x ]

51. Quicksort Algorithm If sequence is empty, then it is sorted Take any element as pivot value Partition rest of sequence into two parts 1.elements < pivot value 2.elements >= pivot value Sort each part using Quicksort Result is sorted part 1, followed by pivot, followed by sorted part 2

52. Quicksort in C qsort( a, lo, hi ) int a[ ], hi, lo; { int h, l, p, t; if (lo < hi) { l = lo; h = hi; p = a[hi]; do { while ((l < h) && (a[l] <= p)) l = l + 1; while ((h > l) && (a[h] >= p)) h = h – 1 ; if (l < h) { t = a[l]; a[l] = a[h]; a[h] = t; } } while (l < h); t = a[l]; a[l] = a[hi]; a[hi] = t; qsort( a, lo, l-1 ); qsort( a, l+1, hi ); }

53. Quicksort in Haskell qsort :: [Int] -> [Int] qsort [] = [] qsort (x:xs) = qsort lt ++ [x] ++ qsort greq where lt = [y | y <- xs, y < x] greq = [y | y = x] qsort:: Ord a => [a]  [a]

54. Lazy Evaluation

57. Do not evaluate an expression unless its value is needed iterate :: (a -> a) -> a -> [a] iterate f x = x : iterate f (f x) interate (*2) 1 => [1, 2, 4, 8, 16, …] powertables :: [[Int]] powertables = [ iterate (*n) 1 | n <- [2..] ] powertables => [ [1, 2, 4, 8,…], [1, 3, 9, 27,…], [1, 4,16, 64,…], [1, 5, 25,125,…], … ]

63. Prime Numbers: Sieve of Eratosthenes Algorithm 1.Generate list 2, 3, 4, … 2.Mark first element p of list as prime 3.Delete all multiples of p from list 4.Return to step 2 primes :: [Int] primes = map head (iterate sieve [2..]) sieve (p:xs) = [x | x <- xs, x `mod` p /= 0 ] takewhile (< 10000) primes

64. Hamming’s Problem Produce the list of integers increasing order (hence no duplicate values) begins with 1 if n is in list, then so is 2*n, 3*n, and 5*n list contains no other elements 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 16, 18, 20, …

65. Hamming Program ham :: [Int] ham = 1 : merge3 [ 2*n | n <- ham ] [ 3*n | n <- ham ] [ 5*n | n <- ham ] merge3 :: Ord a => [a] -> [a] -> [a] -> [a] merge3 xs ys zs = merge2 xs (merge2 ys zs) merge2 xs'@(x:xs) ys'@(y:ys) | x < y = x : merge2 xs ys' | x > y = y : merge2 xs' ys | otherwise = x : merge2 xs ys

66. Parametric Polymorphism+Overloading The list length function: length :: [a] -> Int length [] = 0 length (x : xs) = length xs + 1 What happens when overloaded operators meet parametric polymorphism? double_sum x y = 2*x + 2*y double_sum :: a -> a -> a ??? Too general double_sum :: int -> int -> int ??? Too restricted

67. One more Example: The Membership function Testing membership of a list in Haskell (infix form) x `elem` [] = False x `elem` (y:ys) = x==y || (x `elem` ys) What should be the type for “elem”? elem :: a  [a]  Bool ? Are all types comparable for equality?

68. Type Classes in Haskell (Parametric Overloading) Not all types are comparable for equality. It should be a constraint to the type of “elem”. elem :: For all type a that support equality, a  [a]  Bool A Type Class is a collection of types that support certain operations, called the methods of the class. class Eq a where (==) :: a -> a -> Bool It state that a type a is an instance of the class Eq if there is an (overloaded) operation ==, of the appropriate type, defined on it So the type for “ == “ is Eq a => :: a -> a -> Bool So the type for “elem” should be elem :: Eq a => a  [a]  Bool

69. Instance Declaration for Type Classes Instance declaration: instance Eq Integer where x == y = x `integerEq` y The definition of == is called a method. The function integerEq happens to be the primitive function that compares integers for equality. Composite and User-defined types can be declared to be instances, too. instance (Eq a) => Eq (List a) where lst1 == lst2 = …

70. Type Classes in Haskell, Cont’d Another example of Type class declaration in Haskell class Num a where (+), (-), (*) :: a -> a -> a negate :: a -> a … In Haskell, numeric literals such as 0, 1 are overloaded, too: double_sum x y = 2*x + 2*y –Haskell infers double_sum is a (numerical) function: Num a => a -> a -> a –For all types a that is an instance of type class Num, from a to a.

71. Implementing Type Classes in Haskell Instance Declaration instance Num Int where (*) = IntMul -- primitive fun in Prelude (-) = IntSub -- primitive fun in Prelude … The def. above is turn into a dictionary of methods: NumIntDictionary Dictionary passing style via type inference factorial n = … is translated to factorial NumDict n = n (select ‘*’ from NumSict) factorial (n (select ‘-’ from NumSict) 1) during the type inference process. For “factorial 5”, the NumIntDict is passed.

72. Class Extension in Type Classes Class extension in Haskell: class (Eq a) => Ord a where ( =), (>) :: a -> a -> Bool max, min :: a -> a -> a Note the context in the class declaration. We say that Eq is a superclass of Ord (conversely, Ord is a subclass of Eq ), and any type which is an instance of Ord must also be an instance of Eq.