In Julia, functions are objects like any other. This offers a number of interesting mechanisms, such as for example the ability for a function to return another function. Let’s use a simple example: the logistic map. It is defined by $x_{n+1} = a\times x_n\times(1-x_n)$, and $x_0 \in [0;1]$.

If we wanted to do this calculation, we could write a function that takes two arguments, a and x, and return a*x*(1.0-x). But there is no reason to expect that $a$ (a parameter) will change, so what we might want to do instead is return a function with a “built-in”.

function f(x::Number)
  return a * x * (1.0 - x)
end

f (generic function with 1 method)

Of course this function will not work, because a is currently not defined. And we do not want to hard-code the value of a, since we might want to change this parameter. So ideally, we would like to have a function to write the function f on our behalf.

Because functions are objects like any other, they can actually be returned. So we can write a function that accepts a as its argument, and then returns a function that accepts x as an argument:

function logistic(a::Number)
  return function f(x::Number)
    return a * x * (1.0 - x)
  end
end

logistic (generic function with 1 method)

Now, if we call this function, we can see that it does indeed return a function:

logistic(1.2)

(::Main.##WeaveSandBox#253.var"#f#1"{Float64}) (generic function with 1 met
hod)

We can now use this function to run our model:

m = logistic(1.4)
x0 = 0.5
m(x0)

0.35

This specific design pattern shows up in a bunch of Julia functions: isequal, for example, constructs a function that tests for equality:

istwo = isequal(2)
istwo(2)

true

Sometimes, thinking about returning a function with “built-in” arguments can simplify your high-level code a lot!