1. Functions and patterns
Haskell II
Functions and patterns
27-Jun-18

2. Data Types Int + - * / ^ even odd Float + - * / ^ sin cos pi truncate
Char ord chr isSpace isUpper …
Bool && || not
Lists : ++ head tail last init take
Tuples fst snd
Polymorphic: < <= == /= => > show

3. User-Defined Data Types
data Color = Red | Blue
toString Red = "red" toString Blue = "blue"
data Tree a = Leaf a | Branch (Tree a) (Tree a)
Can be tricky to use

4. Assorted Syntax
Comments are -- to end of line or {- to -} (these may be nested)
Types are capitalized, variables are not
Indentation may be used in place of braces
Infix operators: `mod` `not`
Prefix operators: (+) (-) mod not
Types: take :: Int -> [a] -> [a]

5. Layout
The first nonblank character following where, let, or of determines the starting column
let x = a + b y = a * b in y / x
If you start too far to the left, that may end an enclosing clause
You can use { } instead, but this is not usually done

6. Infinite Lists
[1..5] == [1, 2, 3, 4, 5]
[1..] == all positive integers
[5, ] == [5, 10, 15, 20, 25, 30]
[5, 10..] == positive multiples of 5
[x*x | x <- [1..]] == squares of positive ints
[x*x | x <- [1..], even x] == squares of positive even ints
[(x, y) | x <- [1..10], y <- [1..10], x < y]

8. Functions are also data
Functions are “first-class objects”
Functions can be assigned
Functions can be passed as parameters
Functions can be stored in data structures
There are operations on functions
But functions can’t be tested for equality
Theoretically very hard!

9. Anonymous Functions Form is \ parameters -> body
Example: \x y -> (x + y) / 2
the \ is pronounced “lambda”
the x and y are the formal parameters
inc x = x + 1
this is shorthand for inc = \x -> x + 1
add x y = x + y
this is shorthand for add = \x y -> x + y

10. Currying Technique named after Haskell Curry
Functions only need one argument
Currying absorbs an argument into a function
f a b = (f a) b, where (f a) is a curried function
(avg 6) 8
7.0

11. Slicing Functions may be “partially applied” inc x = x + 1
can be defined instead as inc = (+ 1)
add x y = x + y
can be defined instead as add = (+)
negative = (< 0)

12. map map :: (a -> b) -> [a] -> [b]
applies the function to all elements of the list
Prelude> map odd [1..5]
[True,False,True,False,True]
Prelude> map (* 2) [1..5]
[2,4,6,8,10]

13. filter filter :: (a -> Bool) -> [a] -> [a]
Returns the elements that satisfy the test
Prelude> filter even [1..10]
[2,4,6,8,10]
Prelude> filter (\x -> x>3 && x<10) [1..20]
[4,5,6,7,8,9]

14. iterate iterate :: (a -> a) -> [a] -> [a]
f x returns the list [x, f x, f f x, f f f x, …]
Prelude> take 8 (iterate (2 *) 1)
[1,2,4,8,16,32,64,128]
Prelude> iterate tail [1..3]
[[1,2,3],[2,3],[3],[],
*** Exception: Prelude.tail: empty list

15. foldl foldl :: (a -> b -> a) -> a -> [b] -> a
foldl f i x starts with i, repeatedly applies f to i and the next element in the list x
Prelude> foldl (-) 100 [1..3] 94
94 =

16. foldl1 foldl1 :: (a -> a -> a) -> [a] -> a
Same as: foldl f (head x) (tail x)
Prelude> foldl1 (-) [100, 1, 2, 3] 94
Prelude> foldl1 (+) [1..100]
5050

17. flip flip :: (a -> b -> c) -> b ->a -> c
Reverses first two arguments of a function
Prelude> elem 'o' "aeiou"
True
Prelude> flip elem "aeiou" 'o'
Prelude> (flip elem) "aeiou" 'o'

18. Function composition with (.)
(.) :: (a -> b) -> (c -> a) -> (c -> b)
(f . g) x is the same as f (g x)
double x = x + x quadruple = double . double doubleFirst = (* 2) . head
Main> quadruple 3 12 Main> doubleFirst [3..10] 6

19. span span :: (a -> Bool) -> [a] -> ([a], [a])
Break the lists into two lists
those at the front that satisfy the condition
the rest
Main> span (<= 5) [1..10]
([1,2,3,4,5],[6,7,8,9,10])
Main> span (< 'm') "abracadabra"
("ab","racadabra")

20. break break :: (a -> Bool) -> [a] -> ([a], [a])
Break the lists into two lists
those at the front that fail the condition
the rest
Main> break (== ' ') "Haskell is neat!"
("Haskell"," is neat!")

21. Function Definition I Functions are defined with =
fact n = if n == 0 then 1 else n * fact (n - 1)

22. Function Definition II
Functions are usually defined by cases
fact n | n == = 1 | otherwise = n * fact (n - 1)
fact n = case n of > 1 n -> n * fact (n - 1)
These are “the same”

23. Function Definition III
You can separate the cases with “patterns”
fact :: Int -> Int not essential fact 0 = 1 fact n = n * fact (n - 1)
How does this work?

24. Pattern Matching Functions cannot in general be overloaded
But they can be broken into cases
Each case must have the same signature
fact :: Int -> Int -- explicit signature fact 0 = 1 fact n = n * fact (n - 1)
fact 5 won’t match the first, but will match the second

25. Pattern Types I A variable will match anything
A wildcard, _, will match anything, but you can’t use the matched value
A constant will match only that value
Tuples will match tuples, if same length and constituents match
Lists will match lists, if same length and constituents match
However, the pattern may specify a list of arbitrary length

26. Pattern Types II
(h:t) will match a nonempty list whose head is h and whose tail is t
second (h:t) = head t
Main> second [1..5] 2

27. Pattern Types III “As-patterns” have the form w@pattern
When the pattern matches, the w matches the whole of the thing matched
firstThree = take 3 all
Main> firstThree [1..10]
[1,2,3]

28. Pattern Types IV
(n+k) matches any value equal to or greater than k; n is k less than the value matched
silly (n+5) = n
Main> silly 20 15

29. Advantages of Haskell Extremely concise Easy to understand
no, really!
No core dumps
Polymorphism improves chances of re-use
Powerful abstractions
Built-in memory management

30. Disadvantages of Haskell
Unfamiliar
Slow
because compromises are less in favor of the machine

31. quicksort quicksort [] = [] quicksort (x:xs) =
quicksort [y | y <- xs, y < x] ++
[x] ++
quicksort [y | y <- xs, y >= x]

32. The End