# Some Annotated clojure.core/reduce Examples

### From OO to Clojure Workshop!

Watch my free workshop to help you learn Clojure faster and shift your paradigm to functional.

Summary: *reduce is a very useful function. You can use it for many
calculations over a collection. Code annotations are useful, as are
physical metaphors.*

`reduce`

is used a lot in Clojure. I've heard a lot of people get
scared by `reduce`

, like it's something deep and mysterious. It is
deep, but it's not mysterious. It's also very loveable for its **easy
mechanistic application**.

I love to watch my toddler doing mechanistic stuff. She picks up a bean
and puts it in the cup. She picks up a bean and puts it in the cup.
**Over. And over.** And then I think: that's reduce!

Let's look at a first example. Let's say we want to **add up a list of
numbers**.

```
(reduce +
0
[1 2 3 4 5])
```

let's add

start with zero

add these numbers to it, one at a time

Imagine holding `0`

in your left hand and walking down the list of
numbers `1`

, `2`

, `3`

, `4`

, `5`

. You approach the number `1`

. You grab
it with your right hand. You have two numbers in your hands. You add
them together (`+`

) and hold the answer in your left hand. Now proceed
to the next number. Repeat until you're done with the list. At the end,
what number are you holding in your left hand? That's the answer.

We can add stuff to a set.

```
(reduce conj
#{}
[1 2 3 4 5])
```

let's add things to a collection

start with an empty set

add these numbers to it, one at a time

Imagine holding an empty bucket (like the empty set) in your left hand
and walking down the list of numbers. When you get to `1`

, you pick it
up in your right hand. Now drop it in the bucket (`conj`

). Proceed to
the next number and repeat down the list. What is in your left hand at
the end? A bucket with the numbers 1-5. That's the value of this
expression.

Alright, we can do something more complicated. This time, let's use an anonymous function. We'll calculate the maximum number from a list.

```
(reduce (fn [a b]
(if (> a b)
a
b))
0
[1 2 3 4 5])
```

we can use an anonymous function

return the larger of the two

start with zero

compare these numbers to it, one at a time

Hold `0`

in your left hand and walk down the list. When you get to `1`

,
pick it up. Which is bigger, what's in your left hand or what's in
your right hand? Whichever it is, put that in your left hand and proceed
to the next number, and so on down the line. The answer is in your left
hand.

Hmm. What about averages? We think of averages as the sum of a bunch of numbers divided by the number of numbers. We can keep the sum and the count separate so we can operate on them.

```
(reduce (fn [[n d] b]
[(+ n b)
(inc d)])
[0 0]
[1 2 3 4 5])
```

`n`

is the numerator, `d`

is the denominator

add each number to the numerator

add 1 to the denominator

start here

average these numbers, one at a time

Hold `[0 0]`

in your left hand. Walk down the list. When you get to `1`

,
pick it up in your right hand. Now, add what's in your right hand to
the first number in your left hand, and add 1 to the second number in
your left hand. Hold the two new numbers in your left hand. Proceed down
the line, picking each number up in your right hand, until the end. The
answer is in your left hand. UPDATE: I explain this `reduce`

example in
more detail here.

Now, one final time, the general pattern:

```
(reduce (fn [left right]
(dosomething left right))
starting-value
collection)
```

a function of 2 arguments

the arguments correspond to your hands

the return value of this function will be the next value in your left hand

what you start with in your left hand

the items you grab with your right hand

### Conclusions

Well, that was fun. `reduce`

is not hard. **You just need a good way of
thinking about it.** Physical metaphors can help a ton. I wish I could
have made this visual with a cartoon, but that would take more time and
skill than I have. And I think the code annotations really help add
context to what would otherwise be very terse code. Context is so
important.

If you liked the code annotations and this style of teaching the basics, you will love Lispcast Introduction to Clojure. It has lots of visuals, lots of metaphors, exercises, and code annotations. It teaches the basics of Clojure and functional programming in a fun way. Check out a preview.