Clojure iteration over vector of functions

Question

I am reading a book on Clojure that says:

Another fun thing you can do with map is pass it a collection of functions. You could use this if you wanted to perform a set of calculations on different collections of numbers, like so:

(def sum #(reduce + %))
(def avg #(/ (sum %) (count %)))
(defn stats
  [numbers]
  (map #(% numbers) [sum count avg]))

(stats [3 4 10])
; => (17 3 17/3)

(stats [80 1 44 13 6])
; => (144 5 144/5)

In this example, the stats function iterates over a vector of functions, applying each function to numbers.

I find this very confusing and the book doesn't give any more explanation.

I know % represent arguments in anonymous functions, but I can't work out what values they represent in this example. What are the %'s?

And also how can stats iterate over count if count is nested within avg?

Answer 1

It helps to not think in "code being executed" , but in "expression trees being reduced". Expression trees are rewritten until the result appears. Symbols are replaced by "what they stand for" and functions are applied to their arguments when a "live function" appears in the first position of a list; as in (some-function a b c). This is done in top-down fashion from the top of the expression tree to the leaves, stopping when the quote symbol is encountered.

In the example below, we unfortunately cannot mark what has already been reduced and what not as there is no support for coloring. Note that the order of reduction is not necessarily the one corresponding to what the compiled code issued by the Clojure compiler actually would do.

Starting with:

(defn stats
  [numbers]
  (map #(% numbers) [sum count avg]))

...we shall call stats.

First difficulty is that stats can be called with a collection as a single thing:

(stats [a0 a1 a2 ... an])

or it could be called with a series of values:

(stats a0 a1 a2 ... an)

Which is it? Unfortunately the expected calling style can only be found by looking at the function definition. In this case, the definition says

(defn stats [numbers] ...

which means stats expects a single thing called numbers. Thus we call it like this:

(stats [3 4 10])

Now reduction starts! The vector of numbers that is the argument is reduced to itself because every element of a vector is reduced and a number reduces to itself. The symbol stats is reduced to the function declared earlier. The definition of stats is actually:

(fn [numbers] (map #(% numbers) [sum count avg]))

...which is a bit hidden by the defn shorthand. Thus

(stats [3 4 10])

becomes

((fn [numbers] (map #(% numbers) [sum count avg])) [3 4 10])

Next, reducing the fn expression yields a live function of one argument. Let's mark the live function with a ★ and let's use mathematical arrow notation:

(★(numbers ➜ (map #(% numbers) [sum count avg])) [3 4 10])

The live function is on first position of the list, so a function call will follow. The function call consists in replacing the occurrence of numbers by the argument [3 4 10] in the live function's body and stripping the outer parentheses of the whol expression:

(map #(% [3 4 10]) [sum count avg])

Symbols map, sum, count, avg resolve to known, defined functions, where map and count come from the Clojure core library, and the rest has been defined earlier. Again, we mark them as live:

(★map #(% [3 4 10]) [★sum ★count ★avg]))

Again, the # % notation is a shorthand for a function taking one argument and inserting it into the % position, let's make this evident:

(★map (fn [x] (x [3 4 10])) [★sum ★count ★avg]))

Reducing the fn expression yields a live function of one argument. Again, mark with ★ and let's use mathematical arrow notation:

(★map ★(x ➜ (x [3 4 10])) [★sum ★count ★avg]))

A live function ★map is in head position and thus the whole expression is reduced according to the specification of map: apply the first argument, a function, to every element of the 2nd argument, a collection. We can assume the collection is created first, and then the collection members are further evaluated, so:

[(★(x ➜ (x [3 4 10])) ★sum)
 (★(x ➜ (x [3 4 10])) ★count)
 (★(x ➜ (x [3 4 10])) ★avg)]

Every element of the collection can be further reduced as each has a live function of 1 argument in head position and one argument available. Thus in each case, x is appropriately substituted:

[(★sum [3 4 10])
 (★count [3 4 10])
 (★avg [3 4 10])]

Every element of the collection can be further reduced as each has a live function of 1 argument in head position. The exercise continues:

[ ((fn [x] (reduce + x)) [3 4 10])
  (★count [3 4 10])
  ((fn [x] (/ (sum x) (count x))) [3 4 10])]

then

[ (★(x ➜ (reduce + x)) [3 4 10])
  3
  (★(x ➜ (/ (sum x) (count x))) [3 4 10])]

then

[ (reduce + [3 4 10])
  3
  (/ ((fn [x] (reduce + x)) [3 4 10]) (count [3 4 10]))]

then

[ (★reduce ★+ [3 4 10])
  3
  (/ (*(x ➜ (reduce + x)) [3 4 10]) (count [3 4 10]))]

then

[ (★+ (★+ 3 4) 10)
  3
  (/ (reduce + [3 4 10]) (count [3 4 10]))]

then

[ (★+ 7 10)
  3
  (★/ (★reduce ★+ [3 4 10]) (★count [3 4 10]))]

then

[ 17
  3
  (★/ 17 3)]

finally

[ 17
  3
  17/3]

You can also use function juxt. Try (doc juxt) on the REPL:

clojure.core/juxt
([f] [f g] [f g h] [f g h & fs])
  Takes a set of functions and returns a fn that is the juxtaposition
  of those fns.  The returned fn takes a variable number of args, and
  returns a vector containing the result of applying each fn to the
  args (left-to-right).
  ((juxt a b c) x) => [(a x) (b x) (c x)]

Let's try that!

(def sum #(reduce + %))
(def avg #(/ (sum %) (count %)))
((juxt sum count avg) [3 4 10])
;=> [17 3 17/3]
((juxt sum count avg) [80 1 44 13 6])
;=> [144 5 144/5]

And thus we can define stats alternatively as

(defn stats [numbers] ((juxt sum count avg) numbers))
(stats [3 4 10])
;=> [17 3 17/3]
(stats [80 1 44 13 6])
;=> [144 5 144/5]

P.S.

Sometimes Clojure-code is hard to read because you don't know what "stuff" you are dealing with. There is no special syntactic marker for scalars, collections, or functions and indeed a collection can appear as a function, or a scalar can be a collection. Compare with Perl, which has notation $scalar, @collection, %hashmap, function but also $reference-to-stuff and $$scalarly-dereferenced-stuff and @$collectionly-dereferenced-stuff and %$hashmapply-dereferenced-stuff).

Answer 2

% stands for the first argument of the anonymous function.

(map #(% numbers) [sum count avg]))

Is equivalent to the following:

(map (fn [f] (f numbers)) [sum count avg])

where I have used the regular version rather than the short form version for anonymous functions and explicitly named the argument as 'f". See https://practicalli.github.io/clojure/defining-behaviour-with-functions/anonymous-functions.html for a fuller explanation of short form version.

In Clojure functions are first-class citizens so they can be treated as values and passed to functions. When functions are passed as values this is called generating higher-order functions (see https://clojure.org/guides/higher_order_functions).