Haskell Meetup Session 2

1. Motivation
Sebastian Rettig
“Recursion is important to Haskell because unlike imperative
“Recursion is important to Haskell because unlike imperative
languages, you do computations in Haskell by declaring
languages, you do computations in Haskell by declaring
what something is instead of declaring how you get it.” ([1])
what something is instead of declaring how you get it.” ([1])

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. Haskell Features
● Pure Functional Programming Language
● Lazy Evaluation
● Pattern Matching and Guards
● List Comprehension
● Type Polymorphism

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. Let's 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. 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. Let's 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. …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. 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. Let's 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. …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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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)