Reusing destructuring for multimethods

Question

Is there any way to reuse a destructuring between multiple methods in a multimethod?

(defmulti foo (fn [x] (:a x)))
(defmethod foo :1 [{:keys [a b c d e]}] (str a b c d e))
(defmethod foo :2 [a] "")
(defmethod foo :3 [a] "")

Now this is a trivial example, but imagine we have a much more complicated destructuring with nested maps and I want to use it on all my defmethods for foo. How would I do that?

Answer 1

A practical solution would be to only use the keys that you need for each individual method. An important thing to note about destructuring is that you don't have to bind every value in the collection you're destructuring. Let's say every map passed to this multimethod contains the keys :a through :e, but you only need a couple of those keys per method. You could do something like this:

; note: a keyword can act as a function; :a here is equivalent to (fn [x] (:a x))
(defmulti foo :a)  
(defmethod foo :1 [{:keys [a b c d e]}] (str a b c d e))
(defmethod foo :2 [{:keys [b d]}] (str b d))
(defmethod foo :3 [{:keys [c e a]}] (str a c e))

If you have a complicated nested structure and you want to grab specific values, you can just leave out the keys you don't need, or alternatively, depending on your use case, a let binding within the function definition might end up being easier to read. Steve Losh's Caves of Clojure comes to mind -- in writing a roguelike text adventure game from scratch in Clojure, he used nested maps to represent the state of a game. Initially he wrote some of the functions using destructuring to access the inner bits of the "game state" map, e.g.:

(defmethod draw-ui :play [ui {{:keys [tiles]} :world :as game} screen]
  ...

But then later, he decided to make this code more readable by pulling the destructuring out into a let binding:

(defmethod draw-ui :play [ui game screen]
  (let [world (:world game)
        tiles (:tiles world)
        ...

The point is, if you're working with a deeply nested structure and you want to keep your code simple (especially if you're writing a multimethod with several methods taking that same structure as an argument), you may want to avoid using destructuring and just use let bindings to grab the pieces you want. get-in is a good tool for concisely getting values from nested collections. Going back to the Caves of Clojure example, if Steve just needed the tiles, he could have done something like this:

(defmethod draw-ui :play [ui game screen]
  (let [tiles (get-in game [:world :tiles])
    ...

Personally, I find that much easier to read than mucking up the function arguments with {{:keys [tiles]} :world :as game}.

---

EDIT:

If you really want to avoid having to repeat the destructuring for each multimethod, and you want each method to have the same bindings available, you could write a macro:

(defmulti foo :a)

(defmacro deffoomethod [dispatch-val & body]
  `(defmethod foo ~dispatch-val [{:keys [~'a ~'b ~'c ~'d ~'e]}]
     ~@body))

(deffoomethod 1 (str a b c d e))
(deffoomethod 2 (str b d))
(deffoomethod 3 (str a c e))

(foo {:a 1 :b 2 :c 3 :d 4 :e 5})
;=> "12345"

(foo {:a 2 :b \h :d \i})
;=> "hi"

(foo {:a 3 :b \x :c 0 :d \x :e 0})
;=> "300"

I wouldn't recommend this approach, though, as it breaks macro hygiene. Anyone using this macro has to remember that it binds the symbols a through e to the corresponding keys in the argument, and that could be problematic.