I have been coding in Clojure for 5 years now - but still from time to time I am re-discovering some interesting functions from the clojure.core namespace. Today, I am going to share with you some interesting usages of juxt , some and reduced .

Select several values from a map - with juxt

We have select-keys to create a submap of a map.

(select-keys {:a 1 :b 2 :c 3} [:a :b])

But what if we want to get only the values?

We could chain select-keys and vals :

(-> (select-keys {:a 1 :b 2 :c 3} [:a :b]) vals)

But it doesn’t feel idiomatic.

It’s much cleaner to use juxt :

((juxt :a :b) {:a 1 :b 2 :c 3})

Find an item in a sequence - with some

We can find an item in a sequence with (first (filter ...)) :

(first (filter #(= % :c) [:a :b :c :d]))

But it’s much more idiomatic to use some and a set as a predicate:

(some #{:c} [:a :b :c :d])

It works fine because in clojure, a set behaves as a function that receives an argument and returns it if it belongs to the set - and nil otherwise:

(#{:c} :c)

(#{:c} :a)

Terminates a reduce - with reduced

How do you terminate a reduce once you have found the value that you were looking for?

For instance, let’s imagine that you want to sum a sequence of positive numbers with a tweak: if the sum is greater than 1000 you want to return :big-sum instead of the sum.

You could write it with reduce :

(defn my-sum [s] (let [res (reduce (fn [sum x] (+ sum x)) 0 s)] (if (>= res 1000) :big-sum res))) (my-sum (range 100))

But - inside the reduce - once you have discovered that the sum is greater than 1000 , there is no point of continuing the calculation (because all the numbers are positive).

Let’s terminate our reduce with reduced :