New users of Julia often ask me about the use of the operator. In this post I discuss the most important things one should know about it.

In this the post I use Julia 1.6.3.

Getting started with

Let us start with the basics. Before even understanding what does you probably wonder how you can type it. Fortunately it is easy to check in Julia’s help:

help?> ∘
"∘" can be typed by \circ<tab>

search: ∘

  f ∘ g

  Compose functions: i.e. (f ∘ g)(args...) means f(g(args...)). The ∘ symbol can
  be entered in the Julia REPL (and most editors, appropriately configured) by
  typing \circ<tab>.

  Function composition also works in prefix form: ∘(f, g) is the same as f ∘ g.
  The prefix form supports composition of multiple functions:
  ∘(f, g, h) = f ∘ g ∘ h and splatting ∘(fs...) for composing an iterable
  collection of functions.

As you can see you can easily write in the Julia REPL by typing \circ and pressing the <tab> key. Also most editors that support Julia allow use of this key sequence.

We can also check the Unicode code of :

julia> '∘'
'∘': Unicode U+2218 (category Sm: Symbol, math)

and its UTF-8 representation:

julia> codeunits("∘")
3-element Base.CodeUnits{UInt8, String}:


When f and g are functions then writing f ∘ g creates a new callable object that takes the same arguments as the g function and passes the value returned by calling g to the f function. This operation is called function composition.

Let us check this on some example functions:

julia> c = abs ∘ sin
abs ∘ sin

julia> c(-1)

julia> abs(sin(-1))

Additionally, once the composed object is created it can be easily inspected:

julia> typeof(c)
ComposedFunction{typeof(abs), typeof(sin)}

julia> fieldnames(typeof(c))
(:outer, :inner)

julia> c.outer
abs (generic function with 13 methods)

julia> c.inner
sin (generic function with 13 methods)

As you can see you can:

  • easily identify that some object is a composed function (as it has ComposedFunction type);
  • easily recover the functions that were used in composition.

In some usage scenarios these two properties can be quite useful.

One important feature one has to keep in mind is that you have to put the f ∘ g expression in parentheses if you want to immediately call it:

julia> abs∘sin(-1) # incorrect
abs ∘ -0.8414709848078965

julia> (abs∘sin)(-1) # correct

Rationale for

You might wonder why someone would want to write (f ∘ g)(x) if you can write f(g(x)) or x |> g |> f to get the same. The reason is that f ∘ g is an object that can be passed around. Clearly you could have created an anonymous function e.g. via x -> f(g(x)) or x -> x |> g |> f. However, these approaches are more visually noisy, less explicit, and create a new anonymous function each time they used (which means triggering compilation).

The f ∘ g object is most commonly passed as an argument to higher order functions. Here are some examples:

julia> map(uppercase∘strip, [" a", "b ", " c "])
3-element Vector{String}:

julia> sum(sqrt∘abs, -10:10)

Before I finish let me explain the compilation issue. Start with a fresh Julia session:

julia> x = 1:100;

julia> @time sum(abs∘sin, x);
  0.146191 seconds (446.61 k allocations: 25.602 MiB, 4.85% gc time, 99.78% compilation time)

julia> @time sum(abs∘sin, x);
  0.000011 seconds (3 allocations: 80 bytes)

Now open a new fresh Julia session again:

julia> x = 1:100;

julia> @time sum(x -> abs(sin(x)), x);
  0.150860 seconds (445.16 k allocations: 25.541 MiB, 8.25% gc time, 97.47% compilation time)

julia> @time sum(x -> abs(sin(x)), x);
  0.034172 seconds (54.68 k allocations: 3.256 MiB, 99.82% compilation time)

As you can see in the first case compilation happened only once. The reason is that the type of abs∘sin is always the same (it is ComposedFunction{typeof(abs), typeof(sin)}). On the other hand if you define an anonymous function it gets a distinct type each time it is created:

julia> x -> abs(sin(x))
#5 (generic function with 1 method)

julia> x -> abs(sin(x))
#7 (generic function with 1 method)

Such differences matter most if the higher order function to which you pass the composed function is complex and thus expensive to compile.


Hopefully after reading this post you understand why, how, and when the operator can be used.