# Writing Higher-Order Functions

Take a look at functions as first class citizens and write higher-order functions - functions that act on functions.

## We'll cover the following

In Haskell, functions are **first class citizens**. They are values just like integers or strings and can be parameters and results of functions. Functions that act on other functions or return functions are called **higher-order functions**. They play an important role in functional programming as they allow us to compose elementary functions into more powerful functions.
In the lesson on currying we briefly touched upon this topic, but now we will write our own higher-order functions.

## Introduction to higher-order Functions

To start, let’s look at a simple example of a higher-order function. The function `applyTwice`

takes a function of integers as its first argument and applies it twice to its second argument.

```
applyTwice :: (Int -> Int) -> Int -> Int
applyTwice f x = f (f x)
```

The parentheses in the type declaration are necessary here, as `->`

normally associates to the right. We use them to make it clear that the first argument of `applyTwice`

is a function on integers (`Int -> Int`

), and the second argument is an `Int`

itself.

To try it out, let’s define a few more simple functions:

```
double :: Int -> Int
double x = 2 * x
next :: Int -> Int
next x = x + 1
```

We can then make use of `applyTwice`

like this:

Get hands-on with 1200+ tech skills courses.