# Higher-order functions

In 1.07 Making functions we learned about, well, making functions. So what about higher-order functions? What are they and how do we make them? Simply put, higher-order functions are functions built on top of other functions. Here's a basic example:

``````local run_twice = function(some_function, some_data)
some_function(some_data)
some_function(some_data)
end

run_twice(print, 'Hello World!')
``````

It can take any function and run it twice for you, in this case the `print` function, but it could be any function you pass it. Typically higher-order functions return data. Here's a trickier example that does just that:

``````local twice = function(fn, val)
return fn(fn(val))
end

return num + 4
end

``````

Take a look at the bottom line for a second. We are calling the function `twice` with two arguments, the `add_four` function and the number `12`. The purpose of the `twice` function is to take a value, `12` in this case, and run it through the given function (`add_four`) twice. Now take a look inside the `twice` function. Inside it returns `fn(fn(val))`. Given what we know is being passed to this function, this can be read as saying `add_four(add_four(12))`. The order of operation says to start from the inner-most parenthesis and work your way out:

``````add_four(add_four(12))
``````

becomes

``````add_four(16)
``````

which becomes

``````20
``````

and that is what is returned when you run the code. The power of these higher-order functions is that they are re-usable. You can give the `twice` function anything that takes and returns a value:

``````local twice = function(fn, val)
return fn(fn(val))
end

local double = function(number)
return number * 2
end

return twice(double, 3)
``````

...or similar to our original example:

``````local twice = function(fn, val)
return fn(fn(val))
end

local shout = function(message)
print(message .. '!!')
return message
end

return twice(shout, 'hello')
``````

There are all examples of higher-order functions that accept a function as an argument. Another kind of higher-order function is one that returns another function:

``````local wrapper = function()
return function()
return 'You found the treasure!'
end
end

local kinder_surprise = wrapper()
local secret = kinder_surprise()
return secret
``````

When we ran `wrapper` it returned us another function that we had to invoke to get to the innermost value. To avoid all the variable names, you can save some time and invoke such kinds of functions like so:

``````local wrapper = function()
return function()
return 'You found the treasure!'
end
end

return wrapper()()
``````

## Closures

Which number will print out by running the following code?

``````local number = 3

local closure = function()
local number = 5
return function()
print(number)
end
end

local print_number = closure()
print_number()
``````

Strange?

Ok, so let's try a this same function-returning-a-function thing but passing in some data:

``````local adder = function(a)
return function(b)
return a + b
end
end

``````

The `add_three` variable is assigned a unique and special function. It is assigned the inner function within the adder function, but with the data we passed in now assigned to the `a` variable. Even though the function was returned outside of the scope it was defined in, the scope's data was enclosed inside the returned function until the function was discarded and the program exited. These types of functions are common in situations where a function needs to be generated multiple times but with different data sets.

The data in the closure can also continue to be updated, giving you the ability to make storage containers for your data. Try this out:

``````local make_counter = function()
local number = 0
return function()
number = number + 1
return number
end
end

local count = make_counter()
print(count())
print(count())
print(count())
print(count())
``````

In programs like LÖVE there are callback systems where a similar effect happens:

``````local entity = require('entity')

love.draw = function()
entity:draw()
end
``````

As seen in the previous chapter, the `love.draw` callback is defined in a main.lua file and later invoked somewhere within the game engine. Since `love.draw` was defined in the scope where the entity variable is defined, the entity variable lives on and can be used inside `love.draw` long after the main.lua file is done being invoked.

## Conclusion

Closures take some practice to understand and appreciate, but once you see practical examples of where and how to use them they become an indispensable item on your programming toolbelt. In the previous section we used the term composite data to compare primitive and non-primitive data types. In this section we saw how to go about composing higher-order functions. In the following pages we will cover some higher-order functions that are the building blocks for old and modern software alike.

## Exercises

• In the `make_counter` example above, try generating multiple counters:

``````-- Do the numbers in each counter stay in
-- sync or are they tracked independently?
local count_a = make_counter()
local count_b = make_counter()
``````
• Using the same `make_counter` example, modify it to return a table instead of a function. Within this table, define an `increment` and `decrement` function so that you can make the counter number go up or down. How would you use such a function?