Motivation                 Sebastian Rettig“Recursion is important to Haskell because unlike imperative “Recursion is impo...
Functional Programming●   No Variables●   Functions only, eventually stored in     Modules       –   Behavior do not chang...
Haskell Features●   Pure Functional Programming Language●   Lazy Evaluation●   Pattern Matching and Guards●   List Compreh...
When you start...●   You want to do big projects with Haskell?●   Then start simple, because:          –   a function is S...
Lets start simple●   You need a Framework to start with Haskell?        –   then write one, if you really think you need o...
How to implement the Factorial?●   Remember:    “Recursion is important to Haskell because unlike imperative      language...
Lets look at the imperative way...●   Imperative                    ●   Recursive    function factorial(n) {      int resu...
…and translate to the functional way●   Imperative                    ●   Recursive    function fact(n) {                f...
The maximum value of a List?●   Remember:    “Recursion is important to Haskell because unlike imperative      languages, ...
Lets look at the imperative way...●   Imperative                        ●   Recursive    function max(array list) {      i...
…and translate to the functional way●   Imperative                        ●   Recursive    function max(array list) {     ...
Types in Haskell (1)Starts with uppercase first character●    Int bounded from -2147483648 to 2147483647●    Integer unbou...
Types in Haskell (2)●   Lists: must be homogenous (entries from the same type)        –   [] empty List        –   [Int] L...
List-Functions●   head returns first element of list         –   head [1,2,3] returns 1●   tail returns list without first...
Tuple-Functions●   fst returns first element of a pair             fst (1, “one”) returns 1         –   only usable on Tup...
Type Polymorphism (1)●   Statically typed, but Compiler can read type from      context (type inference)●   → no need to s...
Type Polymorphism (2)●   the header of our previous implementations could be    fact :: Int -> Int    maxList :: [Int] -> ...
Type Polymorphism (3)●   Solution: use Typeclasses    maxList :: (Ord a) => [a] -> a●   then we can be sure to use (<,<=, ...
Typeclasses (1)●   define properties of the types●   like an interface●   Typeclasses:         –   Eq can be compared     ...
Typeclasses (2)●   Typeclasses:         –   Bounded upper/lower bound (minBound, maxBound)         –   Num types behave li...
Lazy Evaluation●   What happens, if I do this? (Yes it makes no     sense, but just for demonstration)    max a b      | a...
Sources[1] Haskell-Tutorial: Learn you a Haskell (http://learnyouahaskell.com/,    2012/03/15)[2] The Hugs User-Manual (  ...
Upcoming SlideShare
Loading in …5
×

02. haskell motivation

659 views

Published on

Haskell Meetup Session 2

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

  • Be the first to like this

02. haskell motivation

  1. 1. Motivation Sebastian Rettig“Recursion is important to Haskell because unlike imperative “Recursion is important to Haskell because unlike imperativelanguages, you do computations in Haskell by declaring languages, you do computations in Haskell by declaringwhat something is instead of declaring how you get it.” ([1]) what something is instead of declaring how you get it.” ([1])
  2. 2. 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)
  3. 3. Haskell Features● Pure Functional Programming Language● Lazy Evaluation● Pattern Matching and Guards● List Comprehension● Type Polymorphism
  4. 4. When you start...● You want to do big projects with Haskell?● Then start simple, because: – a function is Simple and... Abstraction- Simple Level Simple Simple BIG Simple Simple Simple Project Simple Simple Simple Simple
  5. 5. Lets start simple● You need a Framework to start with Haskell? – then write one, if you really think you need one :) – but be aware of ● Haskell == simple ● Framework == should also be simple● a simple function: – just ignore the function header at the beginning countNum 1 = “One” countNum 2 = “Two” countNum x = “toooo difficult to count...”
  6. 6. How to implement the Factorial?● Remember: “Recursion is important to Haskell because unlike imperative languages, you do computations in Haskell by declaring what something is instead of declaring how you get it.” ([1])● Okay, then look at the definition: – Imperative definition – Recursive definition
  7. 7. Lets look at the imperative way...● Imperative ● Recursive function factorial(n) { int result = 1; if (n == 0) return result; } for (int i=1; i<n; i++) { result *= i; } return result; }
  8. 8. …and translate to the functional way● Imperative ● Recursive function fact(n) { fact 0 = 1 int result = 1; fact n = n * fact (n-1) if (n == 0) ● and in comparison with the definition: return result; } for (int i=1; i<n; i++) { result *= i; } ● BUT imperative also possible: return result; } fact 0 = 1 fact n = product [1..n] ● compared with the definition:
  9. 9. The maximum value of a List?● Remember: “Recursion is important to Haskell because unlike imperative languages, you do computations in Haskell by declaring what something is instead of declaring how you get it.” ([1])● Okay, then look at the definition:
  10. 10. Lets look at the imperative way...● Imperative ● Recursive function max(array list) { if (empty(list)) { throw new Exception(); } max = list[0] for (int i=0; i<length(list); i++) { if (list[i] > max) { max = list[i]; } } return max; }
  11. 11. …and translate to the functional way● Imperative ● Recursive function max(array list) { maxList [] = error “empty” if (empty(list)) { maxList [x] = x throw new Exception(); maxList (x:xs) } | x > maxTail = x max = list[0] | otherwise = maxTail for (int i=0; i<length(list); where maxTail = maxList xs i++) { if (list[i] > max) { ● or simpler: max = list[i]; maxList [] = error “empty” } maxList [x] = x } maxList (x:xs) = return max; max x (maxList xs) } ● and in comparison with the definition:
  12. 12. Types in Haskell (1)Starts with uppercase first character● Int bounded from -2147483648 to 2147483647● Integer unbounded (for big numbers) but slower than Int● Float floating point (single precision)● Double floating point (double precision)● Bool boolean● Char character● String list of Char (String == [Char])
  13. 13. Types in Haskell (2)● Lists: must be homogenous (entries from the same type) – [] empty List – [Int] List of Int – But e.g. [Int, Bool] not allowed (not homogenous)!● Tuples: can contain different types BUT have fixed length – () empty tuple (has only 1 value) – (Int, Bool) tuple of a pair Int, Bool – (Int, Bool, Bool) tuple of Int, Bool, Bool
  14. 14. List-Functions● head returns first element of list – head [1,2,3] returns 1● tail returns list without first element – tail [1,2,3] returns [2,3]● init returns list without last element – init [1,2,3] returns [1,2]● last returns last element of list – last [1,2,3] returns 3
  15. 15. Tuple-Functions● fst returns first element of a pair fst (1, “one”) returns 1 – only usable on Tuples of Pairs!!! fst (1,”one”,True) throws Exception!!!● snd returns second element of a pair snd (1, “one”) returns “one” – only usable on Tuples of Pairs!!! – snd (1,”one”,True) throws Exception!!!● zip creates a list of tuples from two lists – zip [1,2,3] [“one”,“two”,”three”] returns [(1,“one”), (2,”two”),(3,”three”)]
  16. 16. Type Polymorphism (1)● 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"
  17. 17. Type Polymorphism (2)● the header of our previous implementations could be fact :: Int -> Int maxList :: [Int] -> Int● but is only limited to Int, but maxList could also handle Char● → why not make it generic? maxList :: [a] -> a● but what happens, if the corresponding Type is not comparable or cannot be ordered?
  18. 18. Type Polymorphism (3)● Solution: use Typeclasses maxList :: (Ord a) => [a] -> a● then we can be sure to use (<,<=, ==, /=, >=, >)● function header can contain multiple typeclasses maxList :: (Ord a, Eq b) => [a] -> [b] -> a● In Haskell-Interpreter: to list the function header :t <function_name>
  19. 19. Typeclasses (1)● define properties of the types● like an interface● Typeclasses: – Eq can be compared – Ord can be ordered (>, <, >=, <=) (extending Eq) – Show can be shown as string – Read opposite of Show – Enum sequentially ordered types (can be enumerated and usable in List-Ranges [a..e])
  20. 20. Typeclasses (2)● Typeclasses: – Bounded upper/lower bound (minBound, maxBound) – Num types behave like numbers (must already be Show, Eq) – Integral contains only integrals (subclass of Num) – Floating corresponding real numbers (subclass of Num)● if all Types of tuple are in same Typeclass → Tuple also in Typeclass
  21. 21. Lazy Evaluation● What happens, if I do this? (Yes it makes no sense, but just for demonstration) max a b | a > b = a | otherwise = b where temp = cycle “LOL ”
  22. 22. Sources[1] Haskell-Tutorial: Learn you a Haskell (http://learnyouahaskell.com/, 2012/03/15)[2] The Hugs User-Manual ( http://cvs.haskell.org/Hugs/pages/hugsman/index.html, 2012/03/15)[3] The Haskellwiki (http://www.haskell.org/haskellwiki, 2012/03/15)

×