Why Haskell Matters

  • 2,089 views
Uploaded on

First presentation of the Vancouver Haskell Meetup. Here we introduce the capabilities of Haskell and some of it's main characteristics as a language

First presentation of the Vancouver Haskell Meetup. Here we introduce the capabilities of Haskell and some of it's main characteristics as a language

More in: Technology , Education
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
No Downloads

Views

Total Views
2,089
On Slideshare
0
From Embeds
0
Number of Embeds
1

Actions

Shares
Downloads
29
Comments
0
Likes
2

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Why Haskell Matters Roman Gonzalez Vancouver Haskell Meetup October 20, 2010
  • 2. So what is this language about? Haskell is a pure, statically typed, lazy functional programming language. → Name inspired by mathematician Haskell Brooks Curry → Based on a more primitive language called Lambda Calculus → There is no iteration or sequences of actions, everything is recursive
  • 3. When learning Haskell is a good idea? → If you are a experienced developer that wants to grow professionally by learning completely new and different approaches to solve problems → If you need to build systems where correctness is critical (Banks, Safety-Critical Systems) → Is well suited to implement Domain Specific Languages, so it could work very well in systems programming → as Erlang, it is easy to implement parallel and concurrent programs safely due to the pureness of the language
  • 4. Benefits of using Haskell → Algorithms are normally shorter and more concise than their iterative versions → Due to the use of function composability, curryfication and high-order functions, code can be reused in really smart ways → The kick-ass type system with type inference makes you develop code that would normally work at the first compilation
  • 5. Properties of Haskell → Functions won’t perform sequentially, instead they will evaluate expressions when needed (lazily) → There is a controlled environment for side effect functions but by default functions are pure (non-side effect). → Management of resources is abstracted completely from the developer (GC and automatic allocation of data included) → Strong typing makes correctness happen, and most of the the issues regarding this type systems won’t get on the way due to the compiler’s type inference system
  • 6. Quicksort in C void qsort(int a[], int lo, int hi) { int h, l, p, t; if (lo < hi) { l = lo; h = hi; p = a[hi]; do { while ((l < h) && (a[l] <= p)) l = l+1; while ((h > l) && (a[h] >= p)) h = h-1; if (l < h) { t = a[l]; a[l] = a[h]; a[h] = t; } } while (l < h); a[hi] = a[l]; a[l] = p; qsort( a, lo, l-1 ); qsort( a, l+1, hi ); } }
  • 7. Quicksort in Haskell qsort :: (Ord a) => [a] -> [a] qsort [] = [] qsort (x:xs) = (qsort lower) ++ [x] ++ (qsort upper) where lower = filter (< x) xs upper = filter (>= x) xs -- qsort [4,5,1,6,3,2] -- First execution: -- x = 4 -- xs = [5,1,6,3,2] -- lower = [1,3,2] -- upper = [5,6]
  • 8. Simple Functions One parameter functions Haskell has only one parameter functions inc :: Int -> Int inc x = x + 1 isNotZero :: Int -> Bool isNotZero x = x /= 0
  • 9. High Order Functions Functions that returns functions add :: Int -> (Int -> Int) add x = y -> x + y compare :: (Eq a) => a -> (a -> Bool) compare a = b -> a == b -- Syntactic Sugar complements of Haskell add’ :: Int -> Int -> Int add’ x y = x + y compare’ :: (Eq a) => a -> a -> Bool compare’ x y = x == y
  • 10. High Order Functions Assign returned functions directly If inc is a function of type: Int -> Int and (+1) is a function of type: Int -> Int Then why don’t assign it directly? This is called curryfication inc’ = (1 +) isNotZero’ = (0 /=)
  • 11. High Order Functions Functions that receive functions as parameters Functions can also receive functions as parameters: filter :: (a -> Bool) -> [a] -> [a] filter fn (x:xs) | fn x = x : filter fn xs | otherwise = filter fn xs -- filter isNotZero [1,0,2,0,3] -- => [1,2,3] They can also be curryfied: removeZeros :: [Int] -> [Int] removeZeros = filter isNotZero
  • 12. Lists Definition of a list → An empty value: [] → A cons value: Item on the left and list on the right, the whole thing being a new list [1,2,3] == (1:2:3:[]) == (1:(2:(3:[]))) So we have two basic functions to get the two components of a cons: head :: [a] -> a head (x:_) = x tail :: [a] -> [a] tail (_:xs) = xs
  • 13. Let’s define some functions Simple functions with a common interface sum :: (Num a) => [a] -> a sum [] = 0 sum (x:xs) = x + sum xs prod :: (Num a) => [a] -> a prod [] = 1 prod (x:xs) = x * prod xs length :: [a] -> Int length [] = 0 length (x:xs) = 1 + length xs
  • 14. Folding Basics foldr :: (a -> b -> b) -> b -> [a] -> b foldr fn zero [] = zero foldr fn zero (x:xs) = fn x (foldr fn zero xs) {- foldr (+) 0 [3,2,5] - [] is replaced by 0 - (:) function is replaced by the (+) function -> 3 : (2 : (5 : [])) -> 3 + (2 + (5 + 0)) -}
  • 15. Folding Using foldr and partially applied functions -- foldr (+) 0 :: (Num a) => [a] -> a sum’ = foldr (+) 0 -- foldr (*) 1 :: (Num a) => [a] -> a prod’ = foldr (*) 1 -- foldr (+) 0 :: (Num a) => [a] -> a length’ = foldr (_ accum -> 1 + accum) 0
  • 16. Folding Insertion Sort insertion :: (Ord a) => a -> [a] -> [a] insertion a [] = [a] insertion a (b:bs) | a <= b = (a:b:bs) | otherwise = (b : insertion a bs) insertionSort :: (Ord a) => [a] -> [a] insertionSort = foldr insertion [] {- insertionSort [3,2,4] -> insertion 3 (insertion 2 (insertion 4 ([]))) -}
  • 17. Function Composition Basics Let’s abstract the composition of functions (.) :: (b -> c) -> (a -> b) -> (a -> c) (.) f g = x -> f (g x) Using the (.) function, we can compose function together to create new ones: map :: (a -> b) -> [a] -> [b] map fn = foldr ((:) . fn) [] -- (x:xs) == (:) x xs -- (:) . fn = x -> (:) fn x
  • 18. Lazy Evaluation Infinite Lists Haskell is a lazy language, meaning that the language will evaluate expressions only one needed. iterate :: (a -> a) -> a -> [a] iterate fn a = (a : iterate fn (fn a)) -- [a, fn a, fn (fn a), fn (fn (fn a))), ...] This will do an infinite recursion, it will stop when algorithms do not require more values from the infinite lists bitValues :: [Int] bitValues = iterate (*2) 1 -- take 8 bitValues -> [1,2,4,8,16,32,64,128]
  • 19. Algebraic Data Types Maybe Data Type To handle nullable values we use an Algebraic Data Type called Maybe data Maybe a = Just a | Nothing deriving (Show) Where the a in the Maybe could be any type (Int, String, Char) Examples of values of type Maybe Int → Just 20 → Nothing
  • 20. Unfolds unfoldr :: (a -> Maybe (b, a)) -> a -> [b] unfoldr fn x = case fn x of Just (a, b) -> a : (unfoldr fn b) Nothing -> []
  • 21. From Int to [Bit] type Bit = Int nextBit :: Int -> Maybe (Bit, Int) nextBit x | x > 0 = Just (m, d) | otherwise = Nothing where d = x ‘div‘ 2 m = x ‘mod‘ 2 toBinary :: Int -> [Bit] toBinary = unfoldr nextBit
  • 22. Binary to Decimal Example of high-order functions, composability and infinite lists zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] zipWith _ _ [] = [] zipWith _ [] _ = [] zipWith fn (x:xs) (y:ys) = (fn x y) : zipWith fn xs ys binaryToDecimal :: [Bit] -> Int binaryToDecimal = sum . zipWith (*) bitValues
  • 23. Why Haskell is not being used as much? → It’s different, people is always afraid of what is different → It’s difficult, mostly related to the first point → It’s unpopular, mostly related to the first and second point → It’s risky (for employers), there are not many Haskell developers to count on, of course this is mostly related to the first, second and third point → Libraries are broad, but there is no depth (Many incompatible experimental libraries that do the same thing)
  • 24. Thank You! Get started at learnyouahaskell.com Github: http://github.com/roman/haskell meetup Twitter: @romanandreg