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))
``````