CSCI-2325 Functional Programming with Haskell Mohammad T . Irfan - - PDF document
12/8/14 CSCI-2325 Functional Programming with Haskell Mohammad T . Irfan Functional Programming u Mimic mathematical functions u No variables in C/Java sense u No assignment statements in C/Java sense u How about loops? u
u Mimic mathematical functions u No variables in C/Java sense u No assignment statements in C/Java sense u How about loops? u Context-independent
u Referential transparency
u Other prime features
u Functions are first-class citizens u Extensive polymorphism u List types and operators u Recursion
John McCarthy LISP(1960) Knight machine (1980s)
u Optional reading
u Scott’s section 11.2.4* (on Blackboard)
u Alonzo Church (1941) u λ expression u Reductions u Example
u λx . x * x * x u Evaluation: (λx . x * x * x) 2 produces 8
u Installation
u http://www.haskell.org/platform/
u Haskell (GHCi) commands
u http://www.haskell.org/ghc/docs/7.4.1/html/
users_guide/ghci-commands.html
u Learning
u Best book: Miran Lipovaca’s Learn You a Haskell
for Great Good!
u http://learnyouahaskell.com/ (free online version)
u Useful how-to page
u http://www.haskell.org/haskellwiki/Category:How_to
u Other resources:
http://www.haskell.org/haskellwiki/Learning_Haskell
u Make a myFunctions.hs file and define the
following functions in it
u doubleMe x = x + x u addSquares x y = x*x + y*y
u Using the terminal go to the folder of that .hs
file
u Execute this command: ghci u Load the .hs file
u :load myFunctions.hs (or, :l myFunctions.hs)
u Use your functions
u addSquares 5 10
u If you change the .hs file => Execute :r to reload
u Extension for Rails project
u Due this Friday
u Haskell and Prolog assignments
u Both due on December 19
u Indentation is important
u Same line is fine
u else is a must! Following doesn’t make sense:
u let x = if a then b
u Nested if? Yes! u Close alternative to if-then-else
u “guard” – not exactly the same
u Problem: Guess a number
guessNumber num = do putStrLn "Enter your guess:" guess <- getLine -- binds the input to guess if read guess < num then do putStrLn "Too low!" guessNumber num else if read guess > num then do putStrLn "Too high!" guessNumber num else do putStrLn "You Win!"
u factorial n
u Try this: factorial 100
Guard
u Can you solve it using if-then-else?
Alias for True
u Want: evens = [0, 2, 4, 6, 8, 10] u In terminal (ghci)
u let evens = [0, 2 .. 10] u evens = [2*x | x <- [0..5] ]
u Infinite list
u let allEvens = [0, 2 ..]
u Two parts
u head u List of the remaining elements (AKA tail)
u Functions head and tail return these
u head evens u tail evens
u Joining head and tail by : operator
u 0 : [2, 4 .. 10] will give [0, 2, 4, 6, 8, 10]
u Reference
u http://www.haskell.org/haskellwiki/How_to_work_on_lists
sort [] = [] sort (head:remainingList) = sort [b | b <- remainingList, b < head] ++ [head] ++ sort [b | b <- remainingList, b >= head]
Empty list List generator
u Example: Factors of a number n
u factors n = [f | f <- [1 .. n], mod n f
== 0] u Example: Compute ALL prime numbers!
u primes = primeGen' [2 ..]
where primeGen' (p:xs) = p : primeGen' [q | q <- xs, mod q p /= 0] u Getting the first 10 prime numbers
u take 10 primes u Side note: This is not really the sieve of Eratosthenes
http://www.cs.hmc.edu/~oneill/papers/Sieve-JFP .pdf
Lazy evaluation
u Recursive sum
u recSum [] = 0
recSum (x:xs) = x + recSum xs u Built-in function that does the above: sum
u sum [1 .. 5]
u Similar built-in function: product
u factorial n = product [1 .. n]
u One function can be a
u One function can return
Haskell Curry
u In GHCI command area:
u This is how Haskell deals with the fun3 function:
Comment
queens n = solve n where solve k | k <= 0 = [ [] ] | otherwise = [ h:partial | partial <- solve (k-1), h <- [0..(n-1)], safe h partial] safe h partial = and [ not (checks h partial i) | i <- [0..(length partial - 1)]] checks h partial i = h == partial!!i || abs(h - partial!!i) == i+1
u map ( > 0) [2, -50, 100] -- à [True, False, True]
u Equivalent: [ x > 0 | x <- [2, -50, 100] ]
u map (`mod` 2) [13, 14, 15] -- à [1, 0, 1]
u Examples u Sorting function (from last class)
qsort [] = [] qsort (x:xs) = qsort (filter (< x) xs) ++ [x] ++ qsort (filter (>= x) xs) qsort [b| b<-xs, b<x] Difference between map and filter?
(From Haskell.org)
u foldl f z [] = z
foldl f z (x:xs) = foldl f (f z x) xs
u foldr f z [] = z
foldr f z (x:xs) = f x (foldr f z xs)
u Example
u foldl (-) 1 [2, 3, 4] u foldr (-) 1 [2, 3, 4] u anyTrue = foldr (||) False [True, True ..] u anyTrue = foldl (||) False [True, True ..]
Accumulator! Binary function
u 10 + (15 – 5) * 4
u + 10 * - 15 5 4
u 10 + 15 – 5 * 4
u + 10 - 15 * 5 4
u Input: String (list of characters) of Polish prefix
expression
u Output: Value of expression u Solution
u Reverse the expr u Traverse it from left to right u Stack operations (implement by a list: head is TOS)
u If the current string is an operator, pop the top two
foldl
evaluate expr = head(foldl stackOperation []
where stackOperation (x:y:xs) curString | curString == "+" = (x+y):xs
stackOperation xs curString = read curString:xs
evaluatePrefix expr = head ( foldl f [] ( reverse (words expr) )
where f (x:y:ys) "*" = (x*y):ys