Presentation is loading. Please wait.

Presentation is loading. Please wait.

Haskell - A Perspective Presented by Gábor Lipták April 2011.

Similar presentations


Presentation on theme: "Haskell - A Perspective Presented by Gábor Lipták April 2011."— Presentation transcript:

1 Haskell - A Perspective Presented by Gábor Lipták April 2011

2 Topics Why? Functional Haskell highlights Development Concurrency approaches Q&A

3 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:)

4 Scalability

5 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

6 Functional?? Object oriented: object method args Functional: function args Lambdas: add' = (+) test1add' = add' 3 5 test2add' = 3 `add'` 5 add'' = \x -> (\y -> x + y) test1add'' = add'' 3 5

7 Purely Functional First class/Higher order functions Pure functions (no side effects) o Immutable data o Referential transparency (each call returns the same result) o Lazy evaluation o Purity and effects (monads) Type system/Type inference Tail recursion Compositional/Declarative/Concise Lazy (vs. eager) evaluation

8 Purity (adapted from Caging the effects monster )Caging the effects monster

9 Introduction Named after Haskell Brooks Curry, was an American mathematician and logician. Two programming languages named after him.Haskell Brooks Curry Lambda calculusLambda calculus is a formal system for function definition, function application and recursion. Prelude> 2^2500 3758280234548012036833624189723865048677365517592586770565238397822316814983377085357 327 2575265884433370245774952605776030922789135161776565190731096878023646469404331623656 214 6724416478591131832593729111221580180531749232777515579969899075142213969117994877343 8020 4942162495440221452939078164756333953502477258490160766686298256791862284963616020887 736 5834950163790188523026247440507390382032188892386109905869706753143243921198482212075 444 0224333665547868565593896895856381265823772240377217022399914414660261857526515029364 722 8091101850032037549633674995156952154185044174792584406629527967187260528579255266013 0702 0479982183347493563216774695296825517658582675027158940078877272500707803502629523772 140 28842297486263597879792176338220932619489509376

10 Reserved Words case class data deriving do else if import in infix infixl infixr instance let of module newtype then type where

11 Polymorphically Statically Typed (type inference) Prelude> :t map map :: (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 = String type PhoneBook = [(Name,PhoneNumber)] Eliminating easy to make errors during compile time.

12 Type Classes square :: Num a => a -> a square x = x *x class Num a where (*) :: a -> a -> a instance Num Int where a * b = mulInt a b -- mulInt is a primitive class Increment a where increment :: Num -> Num instance Increment Int where increment n = n + 1

13 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.

14 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)

15 Tail recursion (and accumulator) my_sum :: [ Integer ] -> Integer my_sum [] = 0 my_sum (x:xs) = x + my_sum xs main :: IO () main = print (my_sum [1.. 10000000]) my_sum :: [ Integer ] -> Integer my_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])

16 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"

17 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

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

19 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

20 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.Monad tutorial You become a real Haskell programmer only after publishing your own Monad Tutorial :)

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

22 QuickCheck Testing invariants in the code Lots of "clones" for other languages import Test.QuickCheck take5 :: [Char] -> [Char] take5 = take 5 main = do quickCheck (\s -> length (take5 s) == 5) quickCheck (\s -> length (take5 s) <= 5) *Main> main *** Failed! Falsifiable (after 1 test): "" +++ OK, passed 100 tests.

23 Other tools Build system: Cabal Package repository: Hackage Code search engine HoogleHoogle Code search engine Hayoo!Hayoo! Haddock documentation tool HUnit (from xUnit series)

24 Concurrency Approaches Explicit (lightweight) threads and STM (software transactional memory) Semi-implicit (`par`, `pseq`) a "hint" Data parallel

25 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

26 Software Transactional Memory atomically :: STM a -> IO a retry :: STM a orElse :: STM a -> STM a -> STM a... newTVar :: a -> STM (TVar a) readTVar :: TVar a -> STM a writeTVar :: TVar a -> a -> STM () Emphasis on composition Similar to database transactions

27 Semi-implicit hard to ensure the right granularity Deterministic Pure: par and seq infixr 0 `par` infixr 1 `pseq` par :: a -> b -> b pseq :: a -> b -> b equivalent to par a b = b pseq a b = _|_ if a = _|_ = b otherwise _|_ (read "bottom", non terminating expression).

28 Example import Control.Parallel cutoff :: Int cutoff = 20 parFib :: Int -> Int parFib n | n < cutoff = fib n parFib n = p `par` q `pseq` (p + q) where p = parFib $ n - 1 q = parFib $ n - 2 fib :: Int -> Int fib 0 = 0 fib 1 = 1 fib n = fib (n - 1) + fib (n - 2) main :: IO () main = print $ parFib 40

29 Dual core $ time./parfib.exe +RTS -N1 102334155 real 0m1.998s user 0m0.015s sys 0m0.015s $ time./parfib.exe +RTS -N2 102334155 real 0m1.337s user 0m0.015s sys 0m0.015s

30 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

31 Final comments Very active community (Haskell Cafe and other mailing lists with very good info to noise ratio)Haskell Cafe and other mailing lists 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

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

33 Q&A


Download ppt "Haskell - A Perspective Presented by Gábor Lipták April 2011."

Similar presentations


Ads by Google