A higher order function is a function for whom at least *one* of the following statements is true:

- It returns a function
- At least one of its arguments is itself a function

Functions with arguments which are themselves functions are typically called *functionals*.

Recall from the previous post that the output of the curry of a function is itself a function. The curry of a function is therefore a higher-order-function.

The examples below demonstrate the case where the *argument* of the function is a function. Namely, the function takes itself as an argument and outputs the composition of itself with itself.

```
main :: IO ()
twice :: (Int -> Int) -> (Int -> Int)
twice f = f . f -- note that . is the composition operator
f :: Int -> Int
f x = 2 * x
main = print (twice f 1) -- 4
```

```
def twice(f: Int => Int) = f compose f
def f(x: Int): Int = 2 * x
println(twice(f)(1)) // 4
```

`map`

One of the most important examples of a higher-order-function is the `map`

function. The `map`

function is a *binary* function. It takes as its arguments a list
$x$ and a function $f$ and returns a new list $y$ such that $y_i = f(x_i)$.

`map f [x1, ... ,xn] == [f x1, ... ,f xn]`

```
scale xs factor = map f xs
where f x = factor * x
main :: IO ()
main = print(scale [1,2,3] 2) -- [2,4,6]
```

```
def scale(xs: List[Int], factor: Int): List[Int] = {
xs map (x => x * factor)
}
println(scale(List(1, 2, 3), 2)) // List(2,4,6)
```

Or we could apply `map`

directly to a list on the fly.

```
val a = List(1,2,3)
val b = a.map((x: Int) => x*2)
println(b) // List(2,4,6)
```