How to select keys in nested maps in Clojure?

10
votes

Let's say I have a map (m) like this:

(def m {:a 1 :b 2 :c {:d 3 :e 4} :e { ... } ....})

I'd like to create a new map only containing :a, :b and :d from m, i.e. the result should be:

{:a 1 :b 2 :d 3}

I know that I can use select-keys to easily get :a and :b:

(select-keys m [:a :b])

But what's a good way to also get :d? I'm looking for something like this:

(select-keys* m [:a :b [:c :d]])

Does such a function exists in Clojure or what's the recommended approach?

5
clojure
For complex nested data structure access, you'll be well served by something like specter github.com/nathanmarz/specter – sw1nn
@sw1nn That was what I was thinking too, but can you come up with the specter solution? – Michiel Borkent
I actually tried specter before writing the question but I couldn't find out how to do this. So a specter answer would be appreciated too :) – Johan

5 Answers

10
votes

In pure Clojure I would do it like this:

(defn select-keys* [m paths]
  (into {} (map (fn [p]
                  [(last p) (get-in m p)]))
        paths))

(select-keys* m [[:a] [:b] [:c :d]]) ;;=> {:a 1, :b 2, :d 3}

I prefer keeping the type of a path regular, so a sequence of keys for all paths. In clojure.spec this would read as 

(s/def ::nested-map (s/map-of keyword? 
                              (s/or :num number? :map ::nested-map)))
(s/def ::path (s/coll-of keyword?))
(s/fdef select-keys*
        :args (s/cat :m ::nested-map 
                     :paths (s/coll-of ::path)))
3
votes

As an alternative you can use destructing on a function, for example:

(def m {:a 1 :b 2 :c {:d 3 :e 4}})

(defn get-m
  [{a :a b :b {d :d} :c}]
  {:a 1 :b b :d d})

(get-m m) ; => {:a 1, :b 2, :d 3}
3
votes

You can use clojure.walk.

(require '[clojure.walk :as w])

(defn nested-select-keys
  [map keyseq]
  (w/postwalk (fn [x]
                (if (map? x)
                  (select-keys x keyseq)
                  (identity x))) map))

(nested-select-keys {:a 1 :b {:c 2 :d 3}} [:a :b :c])
  ; => {:a 1, :b {:c 2}}
2
votes

I'm not aware of such a function being part of Clojure. You'll probably have to write it yourself. I've came up with this :

(defn select-keys* [m v]
  (reduce 
    (fn [aggregate next]
      (let [key-value (if (vector? next)
                        [(last next)
                         (get-in m next)]
                        [next
                         (get m next)])]
        (apply assoc aggregate key-value)))
    {}
    v))
0
votes

Require paths to be vectors so you can use peek (much faster than last). Reduce over the paths like this:

(defn select-keys* [m paths] 
  (reduce (fn [r p] (assoc r (peek p) (get-in m p))) {} paths))

(select-keys* m [[:a] [:b] [:c :d]]) ;;=> {:a 1, :b 2, :d 3}

Of course, this assumes that all your terminal keys are unique.