Ok, in the last post I tantalized you with a silly problem I was trying to solve. I was taking items from a list and using a list comprehension to insert them each into their own map, each with a value of `1`

.

```
```clojure-repl
user=> (for [i [:a :b :c]] {i 1})
({:a 1} {:b 1} {:c 1})
```

That list comprehension is actually part of a function:

```
(defn counts-merge [coll]
(->> (for [i coll] {i 1})
(apply (partial merge-with +))))
```

Here's what it does:

```
(should= {\a 1 \b 2 \c 3 \d 4}
(counts-merge "abbcccdddd"))
```

Yeah, since teasing you in the last post I've discovered that, as usual, coding in Clojure is basically cheating (if you know the right functions to reach for):

```
(should= {\a 1 \b 2 \c 3 \d 4}
(frequencies "abbcccdddd"))
```

Yup, there's a function in `clojure.core`

that does just what I was trying to do. And, arguably, it has a better name.

I was curious to examine its implementation:

```
(persistent!
(reduce (fn [counts x]
(assoc! counts x (inc (get counts x 0))))
(transient {}) coll))
```

Ok, so there are a few strange bits (`persistent!`

and `transient`

). I presume those are performance-related (more on that in a bit). Here's a simplified implementation:

```
(defn- counts-inc [counts x]
(assoc counts x (inc (get counts x 0))))
(defn counts-reduce [coll]
(reduce counts-inc {} coll))
```

It also works as advertised:

```
(should= {\a 1 \b 2 \c 3 \d 4}
(sut/counts-reduce "abbcccdddd"))
```

Tt's not hard to imagine that this solution is just all-around more performant to begin with compared with my original `count-merge`

function. So, let's benchmark it:

And the winner is...

```
1. counts-reduce - 10 x 10000 ops, average per-op: 3036ns
2. frequencies - 10 x 10000 ops, average per-op: 3209ns
3. counts-merge - 10 x 10000 ops, average per-op: 6764ns
```

My simplified `counts-reduce`

function??

Ok, I'm not surprised that `counts-merge`

came in last at roughly `2x`

average duration, but on my machine, the `counts-reduce`

consistently beats out the built-in `frequencies`

. Not by much, but still. Maybe that's something to explore in a future blog post...