04. haskell handling

Handling

Sebastian Rettig

“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])

“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])

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)

Haskell Features

● Pure Functional Programming Language● Lazy Evaluation ● Pattern Matching and Guards● List Comprehension● Type Polymorphism

How to write Functions?

● eventually think about imperative function● and translate into recursive function● → generally the same schema to go for:

– 1. define simple cases (recursion anchor)

– 2. define the recursion call

● lets start with imperative functions

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

Let's look at the imperative way...

● Imperative

function factorial(n) { int result = 1; if (n == 0) return result; } for (int i=1; i<n; i++) { result *= i; } return result;}

● Recursive

…and translate to the functional way

● Imperative

function fact(n) { int result = 1; if (n == 0) return result; } for (int i=1; i<n; i++) { result *= i; } return result;}

● Recursive

fact 0 = 1fact n = n * fact (n-1)

● and in comparison with the definition:

● BUT imperative also possible:

fact' 0 = 1fact' n = product [1..n]

● compared with the definition:

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 recursionisTrue :: Bool � Bool

isTrue b = b && isTrue b

Recursion (2)● Recursion vs. Final Recursion:

● Hugs> countX 3 [1,4,3,5,3]2

● use accumulator to reduce stack usage

● Hugs> countXFinal 3 [1,4,3,5,3] 0 2

countX :: Int -> [Int] -> IntcountX x [] = 0countX x (y:ys) | x==y = 1 + countX x ys | otherwise = countX x ys

countXFinal :: Int -> [Int] -> Int -> IntcountXFinal x [] accu = accucountXFinal x (y:ys) accu | x==y = countXFinal x ys accu+1 | otherwise = countXFinal x ys accu

Where & let .. in

● additional definitions● let .. in defines scope of usage

– let = definition

– in = scope of definition

– e.g.: add x = let a=9 in a + x

● where has scope in whole function– e.g.: add x = a + x

where a=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:

Let's look at the imperative way...

● Imperative

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;}

● Recursive

…and translate to the functional way ● Imperative

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;}

● Recursive

maxList [] = error “empty”maxList [x] = xmaxList (x:xs) | x > maxTail = x | otherwise = maxTail where maxTail = maxList xs

● or simpler:maxList [] = error “empty”maxList [x] = xmaxList (x:xs) = max x (maxList xs)

● and in comparison with the definition:

Final Recursion

● Get maximum element of list in final recursionmaxFinal :: [Int] -> Int -> Int

maxFinal [] accu = accu

maxFinal (x:xs) accu

| x > accu = maxFinal xs x

| otherwise = maxFinal xs accu

● often the same Schema to program

● → there exist functions in haskell to simplify the all day work :)

Simple Recursion Helper

● map

● foldl, foldr, foldl1, foldr1

● scanl, scanr, scanl1, scanr1

● etc...

Lambda Functions

● often called as Inline Functions in other languages

● Syntax:– \<param> <param> → <operation>

– e.g.:\a b -> a+b

– map (\x -> x+3) [2,3,4]

● returns [5,6,7]

Folding, Scanning (1)

● e.g.: How to get the max of an array?– imperative:

int max = 0;

foreach (entry in list) {

max = (entry > max) ? entry : max;

}

– functional: let list = [8,6,4,1,7,3,5]

foldl (\acc x -> if x > acc then x else acc) 0 list

Folding, Scanning (2)

● scan shows the accumulator state on every recursion step:

scanl (\acc x -> if x > acc then x else acc) 0 list

– returns:[0,8,8,8,8,8,8,8]

– good for debugging

– good to understand recursion

Folding, Scanning (3)

● foldl versus foldr: – first we look at the Header of the functions:

Prelude> :t foldl

foldl :: (a -> b -> a) -> a -> [b] -> a

Prelude> :t foldr

foldr :: (a -> b -> b) -> b -> [a] -> b

– What is the difference?

Folding, Scanning (4)

● foldl versus foldr: – first we look at the Header of the functions:

Prelude> :t foldl

foldl :: (a -> b -> a) -> a -> [b] -> a

Prelude> :t foldr

foldr :: (a -> b -> b) -> b -> [a] -> b

– What is the difference?● accumulator and parameter are

switched!!!

Infix, Prefix, Postfix

● Infix (usable in Haskell):– 2 + 3

– 2 `mod` 3

● Prefix (usable in Haskell):– (+) 2 3

– mod 2 3

● Postfix (used in stack machines):– 3 2 +

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)