Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

01. haskell introduction

1,185 views

Published on

Published in: Education, Technology
  • Be the first to comment

01. haskell introduction

  1. 1. Introduction Sebastian Rettig“Work on Haskell began in 1987 when aa committee of “Work on Haskell began in 1987 when committee ofresearchers got together to design aa kick-ass language.”([1]) researchers got together to design kick-ass language.” ([1])
  2. 2. Imperative Programming● Variables (value placeholder) – Value can change during program flow● Modules, Classes, Functions, Procedures● Control Flow Structures (IF THEN ELSE, Loops (WHILE), Goto)
  3. 3. Functional Programming● No Variables● Functions only, eventually stored in Modules – Behavior do not change, once defined – → Function called with same parameter calculates always the same result● Function definitions (Match Cases)● Recursion (Memory)
  4. 4. Haskell Features● Pure Functional Programming Language● Lazy Evaluation● Pattern Matching and Guards● List Comprehension● Type Polymorphism
  5. 5. Haskell Functions (1)● function contains header and body● header consists of type definition: <funcname> :: <param> [ -> <param_n>] -> <result>● body consists of pattern rules and calculation <funcname> <paramalias_1> [<paramalias_n>] = {calc} – more later...● Example (2 params if type [Int] & Int, result Bool): isHead :: [Int] -> Int -> Bool isHead xs i = i==head xs
  6. 6. Haskell Functions (2)● You want an Interface? No Problem myMap :: (Float -> Int) -> [Int] -> [Int]● first parameter of myMap is a function● allows all functions, with Float parameter and result of type Int● interface also individual extendable myMap :: (Float -> Bool -> Int) -> [Int] -> [Int]● or include a sub-level interface myMap :: ((Int -> Float) -> Bool -> Int) -> [Int] -> [Int]
  7. 7. Lazy Evaluation● Function execution only if result is needed● → Program = series of data-transformations● Example: A(B(C(x))) – If A needs result from B → call B – If B needs result from C → call C
  8. 8. Pattern Matching (1)● create matching rules: fac 0 = 1 fac n = n * fac (n-1)● use wildcards to ignore parameters in pattern: take 0 _ = [] take _ [] = [] take n (x:xs) = [x] ++ take (n-1) xs
  9. 9. Pattern Matching (2)● use Guards to separate a matching case deeper: myFilter _ [] = [] myFilter f (x:xs) | f==x = x:myFilter g xs | otherwise = myFilter f xs where g = 2*f – like an IF THEN ELSE – Guard Condition evaluate to Bool (True/False)● eventually define values with where-clause myFilter 2 [1,2,3,4,5,6] results to [2,4]
  10. 10. List Comprehension (1)● Example Quicksort:quicksort [] = []quicksort (x:xs) = quicksort [y | y <- xs,y<x] ++ [x] ++ quicksort[y | y <- xs,y>=x] – Who the f??k needs an array? ● Lists are dynamic, flexible & part of the language definition = deeply integrated – List expression (x:xs) ● x is head of list (value), ● xs is tail (list) ● also individual extendable (x:y:ys) – List Generator: [<value> | <pipe>, <match> ]
  11. 11. List Comprehension (2) void qsort(int a[], int lo, int hi)Quicksort in C: ([2]) { 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 ); } }
  12. 12. List Comprehension (3)● Example: double entries in list doubleList [] = [] doubleList (x:xs) = x:x:doubleList xs● Multiplication of a list of values: Hugs> product [1..5] 120● or in a function: fac n = product [1..n]
  13. 13. Type Polymorphism● Statically typed, but Compiler can read type from context (type inference)● → no need to set type explicitly● → makes function more generic for different kinds of types (type polymorphism) – Why should I use quicksort :: [Int] -> [Int] – even if I also want to sort character? Hugs>quicksort [f,a,d,b] "abdf"
  14. 14. Recursion (1)● we have no loops → use Recursion: myMap :: Int -> [Int] -> [Int] myMap v [] = [] -- Recursion Anchor! myMap v (x:xs) = [v*x] ++ myMap v xs● Recursion Anchor contains the break rule – endless loop = anchorless recursion isTrue :: Bool Bool isTrue b = b && isTrue b
  15. 15. Recursion (2)● Recursion vs. Final Recursion: countX :: Int -> [Int] -> Int ● Hugs> countX 3 [1,4,3,5,3] countX x [] = 0 2 countX x (y:ys) | x==y = 1 + countX x ys | otherwise = countX x ys countXFinal :: Int -> [Int] -> Int -> Int countXFinal x [] accu = accu countXFinal x (y:ys) accu | x==y = countXFinal x ys accu+1 | otherwise = countXFinal x ys accu● use accumulator to reduce stack usage● Hugs> countXFinal 3 [1,4,3,5,3] 0 2
  16. 16. History● Haskell 1.0 (1990) – 1.4● Haskell 98 (1997) – quasi standard language definition – Foreign Function Interface included ([3])● Haskell Prime (2006 = ~) – Haskell 2010 (2009) ● first revision ● → now Control Flow Structures available (Why? I am currently not sure.)
  17. 17. Where to start?● for Beginner – Hugs (Haskell Users Gofer System): – Successor of Gofer Interpreter (http://www.haskell.org/hugs/) – Syntax closer to Miranda than to Haskell, but contains Haskell98 language specification – really smart & easy installation in Mac using brew
  18. 18. Where to start?● for Developer - Haskell Platform – Batteries Included: – Big “Toy” in big Package at (http://hackage.haskell.org/platform/) – Contains Glasgow Haskell Compiler (GHC) ● THE one and only :) ● contains the full 2010 standard ● can also generate .cpp from .hs – Contains Interpreter (GHCi) ● also Bytecode Interpreter like Hugs, but 2010 Standard
  19. 19. Sources[1] Haskell-Tutorial: Learn you a Haskell (http://learnyouahaskell.com/,2012/03/15)[2] Haskell Introduction: Quicksort in C (http://www.haskell.org/haskellwiki/Introduction, 2012/03/15)[3] The Haskell 98 Foreign Function Interface Addendum (http://www.cse.unsw.edu.au/~chak/haskell/ffi/, 2012/03/15)

×