This is the sixth article of a series on the functional language Haskell for beginners

Thank you for joining us for the sixth part of our Haskell series, you will find the previous article here where I explain pattern matching and guards.

In this article we are going to cover higher order functions. It sounds like a big word, but this is something very natural that we are using without realizing it most of the time.

## Definition

If a function does, either or both, of the following:

• Take a function as a parameter
• Return a function

Then it is a "higher order function", otherwise it is known as a "first order function".

A typical example of a higher order function is the `map` function:

As you can see, we call the function `map` with 2 parameters:

• A lambda function (an anonymous function we do not need to define and usually write once - this concept can be found across almost all languages including Haskell) with a parameter `x` which is an element of the list `numbers` and returns the element time 2.
• The list of integers `numbers`.

Because map takes a function (lambda or not) as a parameter, it is therefore a higher order function.

## Curried functions

Now for the big Haskell revelation: Every function in Haskell takes only 1 parameter.

This was a very confusing moment for me and probably for you right now, especially because we declared and used many functions in the previous articles which were using many parameters.

There is a technique that allows us to transform a function which takes many parameters into a function that returns one parameter which returns a function that returns one parameter and so on. This is called "currying", and luckily for us, all functions in Haskell are automatically curried.

Let's try to look at an example:

``````add :: Int -> Int -> Int
add a b = a + b
``````

It is a simple function which takes two `Int`, adds them up and return the result, simple.

Let's load it and run it in  GHCI:

``````ghci> :l high-order.hs
[1 of 1] Compiling Main             ( high-order.hs, interpreted )
4
``````

Works as expected.

What we do not see happening is actually the following:

• The parameter `1` is applied to our function `add`
• This will create a function on the fly which will take 1 parameter and add it to the number  `1`
• The parameter `3` is applied to our previous function
• Then `3` is added to `1` returning `4`

## Partial functions

Now, enough about the theoretical part, it is time to see how we can leverage this currying. In our previous example, when we broke down `add 1 3`, a function was created on the fly on step 2, this is called a partial function. We basically called the function without all its parameters.

Let's try again our `add` function:

``````ghci> let addThree = add 3
8``````

Nice, we are able to create the version of the function created on the fly on the step 2 and reuse it as we want.

Note that you need to "store" it using `let`,  which is an expression used to bind variables. You cannot not respect a function signature in Haskell:

``````ghci> add 3

<interactive>:7:1: error:
• No instance for (Show (Int -> Int)) arising from a use of ‘print’
(maybe you haven't applied a function to enough arguments?)
• In a stmt of an interactive GHCi command: print it
``````

## Functions as a parameter

Now that we have a better understanding about how functions work under the hood with Haskell, let's try to create a higher order function. we are going to create a function which goes through a list and runs a function on every element of the list, then returns the new list (Sounds familiar ? `map` is reserved for the next article, we will get to it no worries).

``````add2 :: (Int -> Int) -> [Int] -> [Int]
add2 f list = [f x | x <- list]``````

So, let's break this down:

• We defined a new function called `add2`
• This function takes 2 parameters:
1. `(Int -> Int)` : This is how you define a function that takes 1 integer and returns 1 integer. Do not mistake it for a tuple `(Int, Int)`. Tuples uses `,` to separate their values, function definitions uses `->`.
2. `[Int]` : This is a list of integers
• And returns a value `[Int]` which is a list of integers

Now for the implementation of the function, it is a very basic list comprehension which calls our function `f` on every element of the list.

Let's try to run it with our partial function from before:

``````ghci> :l high-order.hs
[1 of 1] Compiling Main             ( high-order.hs, interpreted )
ghci> myList = [1, 2, 3, 4, 5]
[4,5,6,7,8]
``````

Looks good ! But what if I do not want to create a (partial or not) function for this purpose ? We talked about lambda functions at the beginning of this article for a python example. Let's try it for Haskell:

``````ghci> add2 (\x->x+3) myList
[4,5,6,7,8]``````

Note that for lambdas, you need to wrap it between `()` and start with a `\`. The backslash is supposed to look like an actual Lambda (the Greek letter λ).

We could actually do the same without redefining an addition function using Haskell simple `+` infix operator:

``````ghci> add2 (+3) myList
[4,5,6,7,8]
``````

## Conclusion

Six down, around four more articles to go ! That's it for the higher order functions in Haskell. Now that we have a good understanding of it, we are going to discuss in our next article about the famous functions `map`, `filter` and `foldl` and how we can compose functions.

PS: Part 7 can be found here.

If you have a problem and no one else can help. Maybe you can hire the Kalvad-Team.