Haskell -  A Perspective

Presented by Gábor LiptákApril 2011

Topics

• Why?• Functional• Haskell highlights• Development• Concurrency approaches • Q&A

Why should you be interested (as a Java, .Net, Ruby developer)?• Knowing this different language will help you improve your

understanding and skills in your "main" language• Research proving ground for features coming to your

language some while later (or to languages hosted on your VM, F#, Scala, Clojure)

• Significant scaling (today)• Fun:)

Scalability

Functional?Programming with (mathematical) functions In functional programming, programs are executed by evaluating expressions, in contrast with imperative programming where programs are composed of statements which change global state when executed. Functional programming typically avoids using mutable state.Prelude> filter even [1..10] filter :: (a -> Bool) -> [a] -> [a]filter _ []                 = []filter p (x:xs) | p x       = x : filter p xs                | otherwise = filter p xs

Functional??

Object oriented: object method args

Functional: function args

Lambdas:

add' = (+)test1add' = add' 3 5test2add' = 3 `add'` 5

add'' = \x -> (\y -> x + y)test1add'' = add'' 3 5

Purely Functional

• First class/Higher order functions• Pure functions (no side effects)

o Immutable datao Referential transparency (each call returns the same

result)o Lazy evaluationo Purity and effects (monads)

• Type system/Type inference• Tail recursion • Compositional/Declarative/Concise • Lazy (vs. eager) evaluation

Purity (adapted from Caging the effects monster)

IntroductionNamed after Haskell Brooks Curry, was an American mathematician and logician. Two programming languages named after him.

Lambda calculus is a formal system for function definition, function application and recursion.

Prelude> 2^2500375828023454801203683362418972386504867736551759258677056523839782231681498337708535732725752658844333702457749526057760309227891351617765651907310968780236464694043316236562146724416478591131832593729111221580180531749232777515579969899075142213969117994877343802049421624954402214529390781647563339535024772584901607666862982567918622849636160208877365834950163790188523026247440507390382032188892386109905869706753143243921198482212075444022433366554786856559389689585638126582377224037721702239991441466026185752651502936472280911018500320375496336749951569521541850441747925844066295279671872605285792552660130702047998218334749356321677469529682551765858267502715894007887727250070780350262952377214028842297486263597879792176338220932619489509376

Reserved Words

• case• class• data• deriving• do• else• if• import• in

• infix• infixl• infixr• instance• let• of• module• newtype• then• type• where

Polymorphically Statically Typed (type inference)Prelude> :t mapmap :: (a -> b) -> [a] -> [b] data Bool = False | True data Roulette = Black | Red | Zero | DoubleZero            deriving (Eq, Ord, Show, Read, Bounded, Enum) type PhoneNumber = String type Name = Stringtype PhoneBook = [(Name,PhoneNumber)] Eliminating easy to make errors during compile time.

Type Classes

square :: Num a => a -> asquare x = x *x

class Num a where    (*)   :: a -> a -> ainstance Num Int where    a * b = mulInt a b -- mulInt is a primitive

class Increment a where    increment :: Num -> Numinstance Increment Int where    increment n = n + 1 

Lazy (thunks)

numsFrom n = n : numsFrom (n+1)squares = map (^2) (numsfrom 0)

take 5 squares => [0,1,4,9,16] 

take 3 (sort xs) Thunk represents an unevaluated expression.Storing and evaluating thunks are costly. 

Folds

foldr (+) 0 (1:2:3:[]) == 1 + foldr (+) 0 (2:3:[])

== 1 + (2 + foldr (+) 0 (3:[])== 1 + (2 + (3 + foldr (+) 0 []))== 1 + (2 + (3 + 0))

foldl (+) 0 (1:2:3:[]) == foldl (+) (0 + 1) (2:3:[])

== foldl (+) ((0 + 1) + 2) (3:[])== foldl (+) (((0 + 1) + 2) + 3) []== (((0 + 1) + 2) + 3)

Tail recursion (and accumulator)my_sum :: [ Integer ] -> Integermy_sum [] = 0my_sum (x:xs) = x + my_sum xs

main :: IO ()main = print (my_sum [1 .. 10000000])

my_sum :: [ Integer ] -> Integermy_sum xs = my_sum' 0 xs  where    my_sum' acc []     = acc    my_sum' acc (x:xs) = my_sum' (acc+x) xs

main :: IO ()main = print (my_sum [1 .. 10000000])

Pattern Matching and Guards

lucky :: (Integral a) => a -> String  lucky 3 = "Lucky Number!"  lucky x = "Sorry, you're out of luck!" numberDesc :: (Integral) => a -> String  numberDesc number      | number < 0 = "negative"      | number > 0 = "positive"    | otherwise   = "zero"   

Higher order functions, currying

map :: (a -> b) -> [a] -> [b]  map _ [] = []  map f (x:xs) = f x : map f xs  mapM :: Monad m => (a -> m b) -> [a] -> m [b]mapM_ :: Monad m => (a -> m b) -> [a] -> m ()  map (+3) [1,5,3,1,6] map (\(a,b) -> a + b) [(1,2),(3,5),(6,3),(2,6),(2,5)]  take5 :: [Char] -> [Char]take5 = take 5

Monads (1)

Monad is a computation returning result of type a Computations are pure during construction, and might have side effects when running (lazy)

Monads (2)

instance Monad Maybe where      return x = Just x      Nothing >>= f = Nothing      Just x >>= f  = f x      fail _ = Nothing   Prelude> Nothing >> Just 3  Nothing  Prelude> Just 3 >> Just 4  Just 4  Prelude> Just 3 >> Nothing  Nothing 

Monads (3)main :: IO ()main = do   putStrLn "Hello, what is your name?"   name <- getLine   putStrLn ("Hey " ++ name ++ "!")More than you care to read (just search for Monad tutorial :) In particular look for parsing examples.

You become a real Haskell programmer only after publishing your own Monad Tutorial :)

Development

Use your editor (vim,Emacs), Leksah, Eclipse, VisualStudio to developProject structures are detailed at haskell.org Use of types (and type signatures) helps to write correct code Profiling (for space "leakage" ...)Listing sparks/concurrency details when running

QuickCheckTesting invariants in the code Lots of "clones" for other languages

import Test.QuickChecktake5 :: [Char] -> [Char]take5 = take 5main = do   quickCheck (\s -> length (take5 s) == 5)   quickCheck (\s -> length (take5 s) <= 5)

*Main> main*** Failed! Falsifiable (after 1 test):""+++ OK, passed 100 tests.

Other tools

• Build system: Cabal • Package repository: Hackage• Code search engine Hoogle • Code search engine Hayoo!• Haddock documentation tool • HUnit (from xUnit series)

Concurrency Approaches

• Explicit (lightweight) threads and STM (software transactional memory)

• Semi-implicit (`par`, `pseq`) a "hint"• Data parallel

Explicit threads

Not dissimilar to threads found in other languages, with same benefits/drawbacks ...• Non-deterministic by design• Monadic: forkIO and STM• forkIO :: IO () −> IO ThreadId• forkOS :: IO () −> IO ThreadId

Software Transactional Memory

atomically :: STM a -> IO aretry :: STM aorElse :: STM a -> STM a -> STM a...

newTVar :: a -> STM (TVar a)readTVar :: TVar a -> STM awriteTVar :: TVar a -> a -> STM ()

Emphasis on compositionSimilar to database transactions

Semi-implicithard to ensure the right granularity• Deterministic• Pure: par and seq

infixr 0 `par`infixr 1 `pseq`par :: a -> b -> bpseq :: a -> b -> b equivalent to  par a b = b pseq a b = _|_ if a = _|_                = b otherwise

_|_ (read "bottom", non terminating expression). 

Example

import Control.Parallel

cutoff :: Intcutoff = 20

parFib :: Int -> IntparFib n | n < cutoff = fib nparFib n = p `par` q `pseq` (p + q)    where      p = parFib $ n - 1      q = parFib $ n - 2

fib :: Int -> Intfib 0 = 0fib 1 = 1fib n = fib (n - 1) + fib (n - 2)

main :: IO ()main = print $ parFib 40

Dual core$ time ./parfib.exe +RTS -N1102334155

real    0m1.998suser    0m0.015ssys     0m0.015s

$ time ./parfib.exe +RTS -N2102334155

real    0m1.337suser    0m0.015ssys     0m0.015s

Data parallel

 (used in languages like High Performance Fortran)• Deterministic• Pure: parallel arrays• Shared memory initially; distributed memory eventually;

possibly even GPUs• mapP :: (a -> b) -> [:a:] -> [:b:]• zipWithP :: (a -> b -> c) -> [:a:] -> [:b:] -> [:c:]• filterP :: (a -> Bool) -> [:a:] -> [:a:] • sumP :: Num a => [:a:] -> a • import GHC.PArr

Final comments

• Very active community (Haskell Cafe and other mailing lists with very good info to noise ratio)

• Great support for algorithms• Lots of libraries (many of them are very specialised)• Very wide use in academia, less outside • Might be hard to find knowledgeable developers

Further informationhaskell.org Real World Haskell Yet Another Haskell TutorialLearn You a Haskell for a Great Good!http://tryhaskell.org/HEAT (Haskell Educational Advancement Tool) Haskell Cheat Sheet The Monad.Reader (if you want to bend your mind :)Simon Peyton-Jones (Principal Researcher at Microsoft) Philip WadlerGalois Multicore/Don StewartMicrosoft Channel9Going Deep Lectures Carnegie Mellon curriculum change

Q&A