1. 1 Haskell Kevin Atkinson John Simmons

2. 2 Contents Introduction Type System Variables Functions Module System I/O Conclusions

3. 3 History of Haskell Named for Haskell Curry Created by committee from FPCA conference, 1987 –Needed a “standard” non-strict, purely functional language Latest version: Haskell 98

4. 4 Goals of the Haskell design Suitability for teaching, research, and applications Complete description via the publication of a formal syntax and semantics Free availability Basis of ideas that enjoy a wide consensus Reduction of unnecessary diversity in functional programming languages

5. 5 Interpreters and Compilers GHC nhc98 HBC / HBI Hugs www.haskell.org/implementations.html

6. 6 Distinguishing features Lazy evaluation Stateless No exception system - errors are considered equivalent to _|_

7. 7 Variants and extensions Parallel variants Object support Pattern guards Views

8. 8 The Haskell type system value :: Type Type inference Pre-defined types –Integer, Real, String, etc. <= case sensitive! –Not special Polymorphic types User-defined types

9. 9 Keywords type and data Enumerated types, renamed types, tuples (record types), lists Type classes –ex. Equality types –Inheritance ex. Equality => Ordered Kinds of types - verify type constructors –* means a value type

10. 10 Thunks and ! Lazy evaluation: the computation needed to compute a field value is stored until needed in a thunk ! Will force immediate evaluation –Can help constrain types –Use with caution

11. 11 Variables No keywords to define Lists (constructor is : ) Arrays –must open the Array module Infinite data structures

12. 12 Basic Stuff Due to layout rules Haskell syntax is rather elegant and generally easy to understand Functions similar to ML Pattern and Wildcards like ML –but also more powerful Pattern Gards –Case clause to pattern match inside of functions Let like ML to define bindings –but also where as part of function and case clause syntax to declare binding after the expression

13. 13 More on Lists [ f x | x <- xs, x < 10 ] –Reads "the list of all f x such that x is drawn from xs where x < 10" –x <- xs is a generator, x < 10 is a guard More than one generator can be specifed: [ (x,y) | x <- xs, y <- ys ] –Which forms the cartesian product of the two lists xs and ys [1.. 10] => [1,2,3,4,5,6,7,8,9,10] [1,3.. 10] => [1, 3, 5, 7, 9] ints = [1, 2..] –take 10 ints => [1,2,3,4,5,6,7,8,9,10] –squares = map (^2) ints –take 3 squares => [1, 3, 9] numsFrom n = n : numsFrom (n+1) ones = 1 : ones

14. Fibonacci fib = 1 : 1 : [ a+b | (a,b) <- zip fib (tail fib) ] –Where zip returns the pairwise interleaving of its two list arguments: zip (x:xs) (y:ys) = (x,y) : zip xs ys zip xs ys = [] –An infinite list, defined in terms of itself, as if it were "chasing its tail."

15. 15 Lazy Evaluation No Fixed Order of Evaluation let f x y = a where a = 20 * b b = x + 5 * c c = y * y As you already see infinite lists are not possible Proving program correctness is nothing more than a mathematical proof. Not so in ML because one still has to worry about order of evaluation Many things that were inefficient with strict evaluation or now possible in Haskell. –Can perform complicated operations by function composition. And Finally … No side effects or State.

16. 16 Standard Prelude. $ $! flip curry/uncurry id const until head/tail ++ length concat reverse zip zipWith map fold* filter take/drop iterate repeat cycle span any/all elem sum/product maximum/minimum lines words

17. 17 Using The Standard Prelude wordCount = length. words fact n = product (take n [1, 2..]) infixl 9.| (.|) = flip (.) doubleSpace = lines.| map (++ “\n\n”).| concat summary = words.| take 20.| unwords wordlist = words.| filter (\x -> length x > 3).| map (to lower).| group.| filter (\x length x >= 3).| map head.| map (++ “\n”).| concat

18. 18 Error Conditions Often handled using the Maybe type defined in the Standard Prelude –data Maybe a = Just a | Nothing doQuery :: Query -> DB -> Maybe Record r :: Maybe Record r = case doQuery db q1 of Nothing -> Nothing Just r1 -> case do Query db (q2 r1) of Nothing -> Nothing Just r2 -> case doQuery db (q3 r2) of Nothing -> Nothing Just r3 ->... Which can get quite tedious after a while There has to be a better way…

19. 19 And there is... thenMB :: Maybe a -> (a -> Maybe b) -> Maybe b mB `thenMB` f = case mB of Nothing -> Nothing Just a -> f a returnMB a = Just a r = doQuery q1 db `thenMB` \r1 -> doQuery (q2 r1) db `thenMB` \r2 -> doQuery (q3 r2) db `thenMB` \r3 -> returnMB r3 And what we have is the mathematical notion of Monad which is formally defined as: return a `then` f === f a m `then` return === m m `then` (\a -> f a `then` h) === (m `then` f) `then` h Monads

20. 20 Haskell Monads In Haskell a Monad is a class defined something like: class Monad m where >>= :: m a -> (a -> m b) -> m b return :: a -> m a So for our Database example we will have something like instance Monad Maybe where (>>=) = thenMB return = returnMB doQuery q1 db >>= \r1 -> doQuery (q2 r1) db >>= \r2 -> doQuery (q3 r2) db >>= \r3 -> return r3 Which can be rewritten using Haskell’s do syntax do r1 <- doQuery q1 db r2 <- doQuery q2 db r3 <- doQuery q3 db return r3

21. 21 Simulating State To simulate state when there is none simply pass in the state and return a copy of the new state. parm -> SomeState -> (res, SomeState) Functions that do so are known as State Transformers. We can model this notation in Haskell using a type synonym type StateT s a = s -> (a, s) parm -> StateT SomeState res

22. 22 State Example addRec :: Record -> DB -> (Bool,DB) addRec :: Record -> StateT DB Bool newDB :: StateT DB Bool newDB db = let (bool1,db1) = addRec rec1 db (bool2,db2) = addRec rec2 db1 (bool3,db3) = delRec rec3 db2 in (bool1 && bool2 && bool3) As you can see this could get quite tedious However, with Monads we can abstract the state passing details away. The details or a bit complicated, but the end result will look something like this: do boo11 <- addRec rec1 bool2 <- addRec rec2 bool3 <- addRec rec3 return (bool1 && bool2 && bool3)

23. 23 I / O To Perform I/O A State Transformer Must be used, for example to get a character: getChar :: FileHandle -> StateT World Char But we must make sure each World is only passed to one function so a Monad is used But this is open to abuse so an ADT must be used: data IO a = IO (StateT World a) So putChar is now: getChar :: FileHandle -> IO Char The end result is that any function which uses I/O must return the IO type. And the only way IO can be executed is by declaring the function “main :: IO ()”.

24. 24 Finally A Complete Program import System (getArgs) main :: IO () main = do args do fstr putStrLn "usage: wc fname"

25. 25 Hudak, P. et al (2000) “A Gentle Introduction to Haskell Version 98” http://www.haskell.org/tutorial Jones, S.P. et al (1999) “The Haskell 98 Report” http://www.haskell.org/onlinereport Winstanley, Noel (1999) “What the Hell are Monads?” http://www.dcs.gla.ac.uk/~nww/Monad.html References