Back when I first started writing Clojure code, I heard
lots about the use of *higher-order functions* (also known as
*HOFs*). Since functions are first-class language members in Clojure,
you can do things like pass them as arguments or return them from
function calls. Any function that accepts or produces another
function in this way is a higher-order function. This allows you to
write some very powerful and consise code, because you can capture the
general *form* of a computation, while allowing its specific
*behavior* to be determined at runtime by the user. You basically say
to the function caller “I’m going to give you *X*, but I’ll make it
however you tell me to”.

So I knew about all this, and could see how powerful a technique it
could be, but I didn’t fully *grok* the whole concept yet. Coming
from a mainly Java background at the time, I hadn’t had any experience
with first-class functions, and still approached everything from a
procedural and object-oriented background. Using HOFs was a bit of an
alien concept.

Clojure is littered with HOFs; if you’re new to the language, you’ve
already used them, perhaps without realizing it. The `map`

function is probably the archetype of a HOF. It iterates through a
sequence of items, applying a function to each one in turn, and
returns a sequence of the results. It says “I’m going to transform
each element of this sequence, but I’ll do it however you tell me to”.
So, you can pass in the `inc`

function to `map`

to increment each
number in a list, like so:

```
(map inc [1 2 3 4 5])
; => (2 3 4 5 6)
```

You can also use an anonymous function (because hey, it’s still a function), allowing you to, say, multiply each number in a list by five:

```
(map #(* 5 %) [1 2 3 4 5])
; => (5 10 15 20 25)
```

All well and good, but this is all still pretty basic. As I said,
these kinds of functions are all over Clojure, and you quickly figure
out how to use them, out of necessity if nothing else; it’s difficult
to do *anything* in Clojure without them! Soon I realized that it
wasn’t the function-*accepting* HOFs that I hadn’t quite gotten; it
was the function-*generating* HOFs that I didn’t fully appreciate.
Clojure has several of these functions, too, and mastering them really
allows you to create some elegant constructs. I’ll mainly talk about
`partial`

and `comp`

, but there are also
`juxt`

and `complement`

, and I may have
overlooked others. And of course, you can always make your own.

The simplest of Clojure’s built-in function generators is probably
`partial`

, which lets you “prime” an existing function with some
number of arguments. For example, you could make a “quintupler”
function like we used above, but using `partial`

like this:

```
(def quintuple (partial * 5))
(map quintuple [1 2 3 4 5])
; => (5 10 15 20 25)
```

This `quintuple`

function is just the standard multplication function
(`*`

), already primed with a first argument of `5`

(it is exactly
equivalent to `(fn [x] (* 5 x))`

). Any other arguments passed into
`quintuple`

will also be multiplied together, and then multiplied by
5. (Though I’ve broken `quintuple`

out as a separate function here,
it is more idiomatic to use it directly, like `(map (partial * 5) [1 2 3 4 5])`

.)

The `comp`

function is a little trickier, but not by much. Short for
“compose”, it carries out the functional composition you learned about
in high school algebra class (you remember *f(g(h(x))*, right?). So
basically, `(comp f g h)`

creates a function that will apply the
function `h`

to its arguments, then apply `g`

to the result, then
apply `f`

to the result of that. Of course, you can supply as many
functions as you like. In this way, it’s similar to (but *not* the
same as!) Clojure’s threading macros (`->`

and `->>`

).

Actually, this whole post is basically an excuse to share the fun
trick I recently discovered. Say you need to condense a sequence of
pairs into a map. No problem, right? We’ll just use `into`

.

```
(def pairs [[:one 1] [:two 2] [:three 3]])
(into {} pairs)
; => {:one 1, :two 2, :three 3}
```

Now for a wrinkle: what if a key repeats?

```
(def pairs [[:one 1] [:two 2] [:three 3]
[:rest 4] [:rest 5] [:rest 6]])
(into {} pairs)
; => {:one 1, :two 2, :three 3, :rest 6}
```

That’s no good; each successive pair with a duplicated key will
overwrite the previous values. What you really want is to create a
*sequence* if there are multiple values, but not if there’s only one.
HOFs to the rescue!

```
(apply merge-with
(comp vec flatten vector)
(map (partial apply hash-map)
pairs))
; => {:rest [4 5 6], :three 3, :two 2, :one 1}
```

That did it! The magic happens with `(comp vec flatten vector)`

.
This generates the function that `merge-with`

will use to combine the
pairs together (once we turn them into maps, that is). If a key is
already present, the function gets called with both the existing value
and the value to be added. This can be a bit tricky to grasp at
first, so I’ll walk through what’s happening step by step.

Keep in mind that our merge function, `(comp vec flatten vector)`

is
only called when there is already a value for a given key. If it’s
the first time we’re merging a particular key, there will be one
value, but for all subsequent times, there will be a vector of values.
We thus have two cases to examine. Since the `comp`

is just composing
`vec`

, `flatten`

, and `vector`

, I’ll split out each operation to show
what happens.

First, we’ll look at what happens the first time we merge a value.
We’ll call the pre-existing value `:A`

and the incoming (to-be-merged)
value `:B`

; in the end, we’ll expect to see `[:A :B]`

.

```
(vector :A :B)
; => [:A :B]
(flatten [:A :B])
; => (:A :B)
(vec '(:A :B))
; => [:A :B]
```

Remember, `comp`

passes the result of one computation as the input to
the next in the chain. In this particular scenario, the calls to
`flatten`

and `vec`

seem unnecessary; after all, we could have stopped
after `vector`

and been done with it. If you’re only ever going to
merge two values, then yes, you could have just used `vector`

… but
that’s not very interesting, is it? Let’s continue on with our
example and merge in an additional value, `:C`

. This time we’re
starting with the vector `[:A :B]`

, which will illustrate the second
case of behavior.

```
(vector [:A :B] :C)
; => [[:A :B] :C]
(flatten [[:A :B] :C])
; => (:A :B :C)
(vec '(:A :B :C))
; => [:A :B :C]
```

Now the need for `flatten`

is apparent; if we didn’t use it, we’d end
up with an increasingly nested set of vectors within vectors within
vectors. By flattening, we eliminate the nesting before it has a
chance to start. But `flatten`

gives us a sequence, and we wanted to
get a vector back. No problem; `vec`

to the rescue! (Strictly
speaking, everything could still work fine without `vec`

, so long as
you don’t mind a mixture of vectors and sequences as values in your
data structure).

Now we can see that in both cases, we end up with a vector of all the
values for a given key being plugged into our growing map. Of course,
the astute reader will recognize the (potential) bug lurking here:
what if one of your values is *already a vector?* If that’s the case,
this particular implementation will not be very kind to you, since it
unmercilessly flattens everything in sight. You can get around this,
though (and I leave that as an exercise for the reader); in this
article I’m focusing on the uses of higher order functions… that,
and the software I wrote this function for never has to deal with
vector values, so there :P

So that covers the `comp`

-generated HOF, but there’s another HOF
lurking in there, too: `(partial apply hash-map)`

. All that does is
convert the vector pairs into maps for feeding into `merge-with`

(we
have to use `apply`

, because `hash-map`

is not expecting a sequence as
input). I told you: HOFs are *everywhere* in Clojure.

Now, contrast this to how I would have written this function when I was young and foolish, pre-HOF:

```
(apply merge-with
(fn [vals v]
(if (vector? vals)
(conj vals v)
[vals v]))
(for [[k v] pairs]
{k v}))
```

Quite a bit more verbose and just *uglier*. Also note that the `(comp vec flatten vector)`

and `(partial apply hash-map)`

functions are more
general and re-usable than their wordier counterparts.

This just shows that you can get the job done in Clojure in any number of ways, but to get really succinct and elegant code, it pays to get familiar with Clojure’s function-generating functions.

Exploration of `juxt`

(quite handy for destructuring `let`

bindings)
and `complement`

(great for use with `filter`

, `remove`

, and other
predicate-consuming functions) are left as exercises for the reader.