Reminder

What is a higher order function?

It's a function that takes another function as an argument.
even 1 False even 2 True map even [1,2,3,4,5] [False,True,False,True,False] filter even [1,2,3,4,5] [2,4]
even is a first-order function.
map and filter are higher-order functions.

Reminder

Passing arguments to higher-order functions

map toUpper "Hello!" == "HELLO!"

map (*3) [1,2,3,4] == [3,6,9,12]

map (take 2) ["Hallo","Haskell"] == ["Ha","Ha"]

filter (not . isSpace) "bla bla \n bla" == "blablabla"

map (\x->x*x) [1,2,3,4] == [1,4,9,16]

We can create functions on-the-fly and use them without giving them an name.

The types of higher order functions

map    :: (a -> b)    -> [a] -> [b]
filter :: (a -> Bool) -> [a] -> [a]

The first argument is a function in both cases.
They are also polymorphic. This is a powerful combination!

Defining map and filter

Using list comprehensions

map    f xs = [f x | x<-xs]

filter p xs = [x   | x<-xs, p x]

Using recursion on lists

map :: (a -> b) -> [a] -> [b]
map f []     = []
map f (x:xs) = f x:map f xs

filter :: (a -> Bool) -> [a] -> [a]
filter p [] = []
filter p (x:xs) | p x       = x:filter p xs
                | otherwise = filter p xs

Revealing some of the magic behind list comprehensions…

An intuition about foldr

Think of
```
foldr
```
as a function that uses an operator to combines all the elements of a list:
- ```
foldr (+) 0 [5,6,7] == 5+6+7+0 == 18
```
In more detail,
```
foldr (&) u
```
(where
```
&
```
is some operator) is a function that
- replaces
```
:
```
  with
```
&
```
  , and
- replaces
```
[]
```
  with
```
u
```
  .

              xs == a : b : c : d : … : []

foldr (&)  u  xs == a & b & c & d & … & u

foldr (+)  0  xs == a + b + c + d + … + 0

foldr (*)  1  xs == a * b * c * d * … * 1

foldr (++) [] xs == a ++ b ++ c ++ d ++ … ++ []

An intuition about foldr

```
foldr f z [1,2,3,4,5]
```
```
foldr f z (1:2:3:4:5:[])
```

Type type of foldr

The definition of
```
foldr
```
:

foldr op u []     = u
foldr op u (x:xs) = x `op` foldr op u xs

The type of
```
foldr
```
:
```
foldr :: (a->b->b) -> b -> [a] -> b
```

Quiz

What do these functions do?

```
f1 xs    = foldr (:) [] xs
```
```
f2 xs ys = foldr (:) ys xs
```
```
f3 f  xs = foldr ((:) . f) [] xs
```

Live Demo

Let's look at some illustrative examples
Source code: HigherOrderFunctions2.hs

More standard higher-order functions

Define
- ```
takeLine :: String -> String
```
such that
- ```
takeLine "abc\ndef\nghi\n" = "abc"
```
Generalize it to
- ```
takeWhile :: (a->Bool) -> [a] -> [a]
```
Also define the complementary
- ```
dropWhile :: (a->Bool) -> [a] -> [a]
```

Lines

Define
- ```
lines :: String -> [String]
```

such that

lines "abc\ndef\nghi\n" = ["abc","def","ghi"]

Generalize it to
- ```
segments :: (a->Bool) -> [a] -> [[a]]
```

Words

Define
- ```
words :: String -> [String]
```

such that

words "abc def  ghi" = ["abc","def","ghi"]

zipWith

Remember zip?

zip [4,5,6] [100,10,1] == [(4,100),(5,10),(6,1)]

```
zip :: [a] -> [b] -> [(a,b)]
```
zip outputs pairs, but we often want do do something with more the pairs

zipWith :: (a->b->c) -> [a] -> [b] -> [c]

Scalar product

Computing scalar product (dot product) using
```
zipWith
```

scalarProduct xs ys = sum (zipWith (*) xs ys)

Example:

```
scalarProduct [4,5,6] [100,10,1]
```
```
==
```

sum (zipWith (*) [4,5,6] [100,10,1]) == sum [400,50,6] == 456

More zipWith

zipWith  :: (a->b->c) -> [a] -> [b] -> [c]

zipWith3 :: (a->b->c->d) -> [a] -> [b] -> [c] -> [d]

zipWith4 :: (a->b->c->d->e) -> [a] -> [b] -> [c] -> [d] -> [e]

There is also
```
zipWith5
```
,
```
zipWith6
```
and
```
zipWith7
```
in the libraries.

Even more zipWith

zipWith0 :: a -> [a]

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

zipWith  :: (a->b->c) -> [a] -> [b] -> [c]

zipWith3 :: (a->b->c->d) -> [a] -> [b] -> [c] -> [d]

zipWith4 :: (a->b->c->d->e) -> [a] -> [b] -> [c] -> [d] -> [e]

There is also
```
zipWith5
```
,
```
zipWith6
```
and
```
zipWith7
```
in the libraries.
But
```
zipWith0
```
and
```
zipWith1
```
have different names in the libraries.
- Which names do they have?
  zipWith1
  is
  map
  ,
  zipWith0
  is called
  repeat
Advanced exercise: could we generalize and do all this with fewer functions, and without an arbirary upper limit on the number of lists?

Function composition

Example: remove white space from a string

removeSpaces "abc def \n ghi" == "abcdefghi"

We can use isSpace from module Data.Char,

removeSpaces s = filter (not . isSpace) s

Function composition is defined as
- ```
(f . g) x = f (g x)
```
What is the type of
```
(.)
```
?
```
(b->c) -> (a->b) -> (a->c)
```

Function composition

Composing many functions

If we had to write it without using function composition:
- ```
 f x = f1 (f2 (f3 (f4 (f5 x))))
```
With function composition:
- ```
 f x = (f1 . f2 . f3 . f4 . f5) x
```
Can we simplify it further?

Eta conversion

Consider definitions of the form
- ```
f x = g x
```
We are saying that f is the same function as g. This can be said in a simpler way:
- ```
f = g
```
This is called Eta (η) conversion/reduction/expansion.
Caveat: the monomorphism restriction in Haskell:
- A definition without parameters and without a type signature is not allowed to be overloaded.

Eta conversion examples

or     = foldr (||) False
and    = foldr (&&) True
concat = foldr (++) []

removeSpaces = filter (not . isSpace)

unlines = foldr (\xs ys->xs++"\n"++ys) []

f = f1 . f2 . f3 . f4 . f5

Exercise

What is the type of these functions:

mm f xs = map (map f) xs

zwzw f xs ys = zipWith (zipWith f) xs ys

Equivalent definitions using function composition and eta reduction:
- ```
mm = map . map

zwzw = zipWith . zipWith
```

Functions returning functions?

If passing functions as arguments is powerful, how about returning functions as results?

Compare these types:

```
Int -> Int -> Int
```
```
Int -> (Int -> Int)
```
```
(Int -> Int) -> Int
```

Which of these types are equal, which are different?

Functions returning functions?

Answer:
```
Int -> Int -> Int
```
is the same as
```
Int -> (Int -> Int)
```
These are the same:
- A function that takes two argument
- A function that takes one argument and returns a function that takes one argument.
- Another example: function composition
  - (b->c)->(a->b)->(a->c)
  - (b->c)->(a->b)-> a->c

Curried functions

Compare these types:
1. ```
Int -> Int -> Int
```
2. ```
(Int,Int) -> Int
```
Both are in effect functions that take two
```
Int
```
s and return an
```
Int
```
.
We have seen that Haskell favours the first variant.
- Such functions are called curried functions, after the logician Haskell Curry.
- Incidentally (or not) the Haskell language is also named after Haskell Curry.

Curried functions

Uncurried vs curried functions as tables

In math, functions are sometimes illustrated as tables (example)
(Int,Int)->Int
In Out
(1,1) 2
(1,2) 3
(2,1) 3
(2,2) 4

Int->Int->Int
In Out
1
In Out
1 2
2 3

2
In Out
1 3
2 4

Curry and uncurry

There are standard functions that convert between the curried and uncurried forms of functions:

curry  :: ((a,b)->c) -> (a->b->c)
curry f x y = f (x,y)

uncurry :: (a->b->c) -> ((a,b)->c)
uncurry f (x,y) = f x y

Extra

Higher order functions in other languages?

Consider these generic sorting functions in Haskell:

sort   :: Ord a            => [a] -> [a]
sortBy :: (a->a->Ordering) -> [a] -> [a]

Compare with a generic sorting function in C:
- void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));

Extra

From the lambda (λ) calculus

Alpha (α) conversion:
```
\x -> x*x 
```
```
==
```
```
 \y -> y*y
```
Beta (β) conversion:
```
(\x -> x*x) 5 
```
```
==
```
```
 5*5
```
Eta (η) conversion:
```
\x -> f x 
```
```
==
```
```
 f 
```

Higher order functions 2

The Heart and Soul of Functional Programming

Reminder

What is a higher order function?

Reminder

Passing arguments to higher-order functions

The types of higher order functions

Defining map and filter

An intuition about foldr

An intuition about foldr

Type type of foldr

Quiz

What do these functions do?

Live Demo

More standard higher-order functions

Lines

Words

zipWith

Scalar product

More zipWith

Even more zipWith

Function composition

Function composition

Composing many functions

Eta conversion

Eta conversion examples

Exercise

Functions returning functions?

Functions returning functions?

Curried functions

Curried functions

Uncurried vs curried functions as tables

Curry and uncurry

Extra

Higher order functions in other languages?

Extra

From the lambda (λ) calculus

Extra

Quiz

How many arguments do the following functions have?