Positional Destructing Functions

Question

I'm new to clojure and I'm trying to understand as much as possible but the documentations are so vague

when you have a function

(fn [_ {:keys [kind]}] kind)

my understanding is that the function takes a vector map but only wants access to a key as specified by the second param {:keys..... correct?

Then how many parameters do I pass to this function? 1 or 2?

is it a vector? {:kind 1 :dog 2} or the vector key value (:kind {....})?

Answer 1

Let's give the function a name:

(defn splot [_ {:keys [kind]}] kind)

This is shorthand for

(defn splot [_ {kind :kind}] kind)

• a function of two (positional) arguments:

  1. _, conventionally unused, and
  2. an anonymous map, which has its :kind entry bound to local kind;

• which then returns whatever is bound to kind.

Bindings that fail return nil.

For examples:

(splot "..." 6)            ;nil
(splot "..." {})           ;nil
(splot "..." {:kind 77})   ;77

Answer 2

It's fairly straightforward to see what a given function syntax does by trying it in the repl.

+user=> ((fn [_ {:keys [kind]}] kind) (:kind {}))
ArityException Wrong number of args (1) passed to: user/eval1/fn--3  clojure.lang.AFn.throwArity (AFn.java:429)
+user=> ((fn [_ {:keys [kind]}] kind) nil (:kind {}))
nil
+user=> ((fn [_ {:keys [kind]}] kind) nil {:kind 1})
1

the {:keys []} destructuring syntax is described pretty comprehensively in the official docs, and describes a shorthand to bind values that come from a hashmap. In Clojure {} is a hashmap, and [] is a vector, and these are not interchangeable. (:foo m) invokes get to look up the value under the key :foo in m. (let [{:keys [foo]} {:foo "bar"}] ...) and (let [foo (:foo {:foo "bar"})] ...) are equivalent.

Answer 3

Your function expects two parameters (has arity 2.) The first parameter's name is _ (underscore,) which conventionally denotes a variable which is not used. (It is a valid variable name, and it becomes bound, but by convention it is not used, so it denotes a placeholder.)

The second parameter is destructured - {:keys [kind]}, which means that the expected value is a map, and as a result of destructuring a variable named kind will be bound to the value of key :kind of the actual parameter (or nil if there is no such key.)

So your function expects two parameters, the first is ignored, the second must be a map with a key :kind (maybe other keys as well, but they are ignored.)

((fn [_ {:keys [kind]}] kind) :foo {:kind :bar, :color :green})
=> :bar

P.S. I have looked at your question again, and I realised where your confusion may be coming from. The syntax [_ {:kind [kind]}] looks like a vector that includes a map at the second position. That's correct, but not everywhere in Clojure a vector notation means you can stick a vector there. Clojure users square brackets for a list of formal parameters of a function - it is part of a common pattern in Clojure of using vector literals everywhere a sequence may be expected. It is in fact very convenient, compared to other Lisps where you need to carefully use quotes in many places to avoid interpreting your lists as function application forms. But that's a digression, the important point is in fn (and defn) the square brackets denote parameter list and do not mean that the parameter is a vector.