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.
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
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
xwhich is an element of the list
numbersand returns the element time 2.
- The list of integers
Because map takes a function (lambda or not) as a parameter, it is therefore a higher order function.
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 ) Ok, one module loaded. ghci> add 1 3 4
Works as expected.
What we do not see happening is actually the following:
- The parameter
1is applied to our function
- This will create a function on the fly which will take 1 parameter and add it to the number
- The parameter
3is applied to our previous function
3is added to
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
ghci> let addThree = add 3 ghci> addThree 5 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
- This function takes 2 parameters:
(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
[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 ) Ok, one module loaded. ghci> let addThree = add 3 ghci> myList = [1, 2, 3, 4, 5] ghci> add2 addThree myList [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]
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
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.