Advanced Programming Languages Lecture 1 NCCU CS Dept. Fall 2005 Sept. 19, 2005.
-
date post
21-Dec-2015 -
Category
Documents
-
view
214 -
download
1
Transcript of Advanced Programming Languages Lecture 1 NCCU CS Dept. Fall 2005 Sept. 19, 2005.
Topics
• Haskell, Part 1• Lambda Calculus• Operational Semantics• Denotational Semantics• Polymorphism & Type Inference• Haskell, Pat 2 (Type classes, …)• Subtyping and OO• Research Papers
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
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
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.
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, …
Orderly Expressions andDisorderly 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
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
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
Haskell: 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.html– http://www.cs.chalmers.se/Cs/Grundutb/Kurser/d1pt/d1pta/externa
l.html
Haskell TimelineSept 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 reportApr 97: Haskell 1.4 (213pp)
Feb 99: Haskell 98 (240pp)
Dec 02: Haskell 98 revised (260pp)
The Book!
• Definitions name :: type
e.g.:size :: Intsize = 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
Currying and Partial Evaluation
add :: (Int,Int) -> Intadd (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)
Fold Right
Abstract different binary operators to be applied
foldr :: (a -> b -> b) -> b -> [a] -> b foldr f z [] = z -- binary op, identity, listfoldr f z (x:xs) = f x (foldr f z xs)
sumlist :: [Int] -> Intsumlist xs = foldr (+) 0 xs
concat' :: [[a]] -> [a]concat' xss = foldr (++) [] xss
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 ]
Quicksort Algorithm
• If sequence is empty, then it is sorted
• Take any element as pivot value
• Partition rest of sequence into two parts1. 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
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 ); } }
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 <- xs, y >= x]
qsort:: Ord a => [a] [a]
Lazy Evaluation 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,…], … ]
Prime Numbers: Sieve of Eratosthenes Algorithm
1. Generate list 2, 3, 4, … 2. Mark first element p of list as prime3. 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
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, …
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
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
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?
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 -> BoolIt 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
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 = …
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.
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.
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.