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:

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

(my-sum-opt (range 100))