02. haskell motivation

Motivation

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

When you start...

● You want to do big projects with Haskell?

● Then start simple, because:

– a function is Simple and...

Simple Simple Simple Simple

Simple Simple

Simple Simple

Simple

SimpleAbstraction- Level

BIGProject

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...”

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:

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:

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

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

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

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

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"

Type Polymorphism (2)

● the header of our previous implementations could befact :: 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?

Type Polymorphism (3)

● Solution: use TypeclassesmaxList :: (Ord a) => [a] -> a

● then we can be sure to use (<,<=, ==, /=, >=, >)

● function header can contain multiple typeclassesmaxList :: (Ord a, Eq b) => [a] -> [b] -> a

● In Haskell-Interpreter: to list the function header

:t <function_name>

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

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

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 ”

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)