Julia Language Closures Function Composition
Example
We can define a function to perform function composition using anonymous function syntax:
f ∘ g = x -> f(g(x))
Note that this definition is equivalent to each of the following definitions:
∘(f, g) = x -> f(g(x))
or
function ∘(f, g)
x -> f(g(x))
end
recalling that in Julia, f ∘ g is just syntax sugar for ∘(f, g).
We can see that this function composes correctly:
julia> double(x) = 2x
double (generic function with 1 method)
julia> triple(x) = 3x
triple (generic function with 1 method)
julia> const sextuple = double ∘ triple
(::#17) (generic function with 1 method)
julia> sextuple(1.5)
9.0
0.5.0
In version v0.5, this definition is very performant. We can look into the LLVM code generated:
julia> @code_llvm sextuple(1)
define i64 @"julia_#17_71238"(i64) #0 {
top:
%1 = mul i64 %0, 6
ret i64 %1
}
It is clear that the two multiplications have been folded into a single multiplication, and that this function is as efficient as is possible.
How does this higher-order function work? It creates a so-called closure, which consists of not just its code, but also keeps track of certain variables from its scope. All functions in Julia that are not created at top-level scope are closures.
0.5.0
One can inspect the variables closed over through the fields of the closure. For instance, we see that:
julia> (sin ∘ cos).f
sin (generic function with 10 methods)
julia> (sin ∘ cos).g
cos (generic function with 10 methods)
