Haskell

1. Haskell Kevin Atkinson John Simmons

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

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. 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. Interpreters and Compilers • GHC • nhc98 • HBC / HBI • Hugs • www.haskell.org/implementations.html

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

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

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. User-defined types • 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. 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. Variables • No keywords to define • Lists (constructor is : ) • Arrays • must open the Array module • Infinite data structures

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. 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 yszip xs ys = [] • An infinite list, defined in terms of itself, as if it were "chasing its tail."

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. 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. 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. 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 Recordr = 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 -> NothingJust r3 -> ... • Which can get quite tedious after a while • There has to be a better way…

19. Monads • And there is... • thenMB :: Maybe a -> (a -> Maybe b) -> Maybe bmB `thenMB` f = case mB of Nothing -> Nothing Just a -> f areturnMB 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 === mm `then` (\a -> f a `then` h) === (m `then` f) `then` h

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. 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. State Example • addRec :: Record -> DB -> (Bool,DB) • addRec :: Record -> StateT DB Bool • newDB :: StateT DB BoolnewDB 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. 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. Finally A Complete Program • import System (getArgs)main :: IO ()main = do args <- getArgs case args of[fname] -> do fstr <- readFile fname let nWords = length . words $ fstr nLines = length . lines $ fstr nChars = length fstr putStrLn . unwords $ [ show nLines , show nWords , show nChars , fname] _ -> putStrLn "usage: wc fname"

25. References • 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