CODEWITHSUNDEEP
clojuremacros
Phil Cooper
Phil Cooper

Reputation: 5877

Using let style destructuring for def

Is there a reasonable way to have multiple def statements happen with destructing the same way that let does it? For Example:

(let [[rtgs pcts] (->> (sort-by second row)
                       (apply map vector))]
 .....)

What I want is something like:

(defs [rtgs pcts] (->> (sort-by second row)
                       (apply map vector)))

This comes up a lot in the REPL, notebooks and when debugging. Seriously feels like a missing feature so I'd like guidance on one of:

A super short experiment give me something like:

(defmacro def2 [[name1 name2] form] 
  `(let [[ret1# ret2#] ~form]
      (do (def ~name1 ret1#)
      (def ~name2 ret2#))))

And this works as in:

(def2 [three five] ((juxt dec inc) 4))
three ;; => 3
five ;; => 5

Of course and "industrial strength" version of that macro might be:

Upvotes: 2

Views: 194

Answers (2)

madstap
madstap

Reputation: 1552

While I agree with Josh that you probably shouldn't have this running in production, I don't see any harm in having it as a convenience at the repl (in fact I think I'll copy this into my debug-repl kitchen-sink library).

I enjoy writing macros (although they're usually not needed) so I whipped up an implementation. It accepts any binding form, like in let.

(I wrote this specs-first, but if you're on clojure < 1.9.0-alpha17, you can just remove the spec stuff and it'll work the same.)

(ns macro-fun
  (:require
   [clojure.spec.alpha :as s]
   [clojure.core.specs.alpha :as core-specs]))

(s/fdef syms-in-binding
  :args (s/cat :b ::core-specs/binding-form)
  :ret (s/coll-of simple-symbol? :kind vector?))

(defn syms-in-binding
  "Returns a vector of all symbols in a binding form."
  [b]
  (letfn [(step [acc coll]
            (reduce (fn [acc x]
                      (cond (coll? x) (step acc x)
                            (symbol? x) (conj acc x)
                            :else acc))
                    acc, coll))]
    (if (symbol? b) [b] (step [] b))))

(s/fdef defs
  :args (s/cat :binding ::core-specs/binding-form, :body any?))

(defmacro defs
  "Like def, but can take a binding form instead of a symbol to
   destructure the results of the body.
   Doesn't support docstrings or other metadata."
  [binding body]
  `(let [~binding ~body]
     ~@(for [sym (syms-in-binding binding)]
         `(def ~sym ~sym))))


;; Usage

(defs {:keys [foo bar]} {:foo 42 :bar 36})

foo ;=> 42

bar ;=> 36

(defs [a b [c d]] [1 2 [3 4]])

[a b c d] ;=> [1 2 3 4]

(defs baz 42)

baz ;=> 42

About your REPL-driven development comment:

I don't have any experience with Ipython, but I'll give a brief explanation of my REPL workflow and you can maybe comment about any comparisons/contrasts with Ipython.

I never use my repl like a terminal, inputting a command and waiting for a reply. My editor supports (emacs, but any clojure editor should do) putting the cursor at the end of any s-expression and sending that to the repl, "printing" the result after the cursor.

I usually have a comment block in the file where I start working, just typing whatever and evaluating it. Then, when I'm reasonably happy with a result, I pull it out of the "repl-area" and into the "real-code".

(ns stuff.core)

;; Real code is here.
;; I make sure that this part always basically works,
;; ie. doesn't blow up when I evaluate the whole file

(defn foo-fn [x]
  ,,,)

(comment

  ;; Random experiments.

  ;; I usually delete this when I'm done with a coding session,
  ;; but I copy some forms into tests.

  ;; Sometimes I leave it for posterity though,
  ;; if I think it explains something well.

  (def some-data [,,,])

  ;; Trying out foo-fn, maybe copy this into a test when I'm done.
  (foo-fn some-data)

  ;; Half-finished other stuff.
  (defn bar-fn [x] ,,,)

  (keys 42) ; I wonder what happens if...

  )

You can see an example of this in the clojure core source code.

Upvotes: 4

Josh
Josh

Reputation: 4806

The number of defs that any piece of clojure will have will vary per project, but I'd say that in general, defs are not often the result of some computation, let alone the result of a computation that needs to be destructured. More often defs are the starting point for some later computation that will depend on this value.

Usually functions are better for computing a value; and if the computation is expensive, then you can memoize the function. If you feel you really need this functionality, then by all means, use your macro -- that's one of the sellings points of clojure, namely, extensibility! But in general, if you feel you need this construct, consider the possibility that you're relying too much on global state.

Just to give some real examples, I just referenced my main project at work, which is probably 2K-3K lines of clojure, in about 20 namespaces. We have about 20 defs, most of which are marked private and among them, none are actually computing anything. We have things like:

(def path-prefix "/some-path")
(def zk-conn (atom nil))
(def success? #{200})
(def compile* (clojure.core.memoize/ttl compiler {} ...)))
(def ^:private nashorn-factory (NashornScriptEngineFactory.))
(def ^:private read-json (comp json/read-str ... ))

Defining functions (using comp and memoize), enumerations, state via atom -- but no real computation.

So I'd say, based on your bullet points above, this falls somewhere between 2 and 3: it's definitely not a common use case that's needed (you're the first person I've ever heard who wants this, so it's uncommon to me anyway); and the reason it's uncommon is because of what I said above, i.e., it may be a code smell that indicates reliance on too much global state, and hence, would not be very idiomatic.

One litmus test I have for much of my code is: if I pull this function out of this namespace and paste it into another, does it still work? Removing dependencies on external vars allows for easier testing and more modular code. Sometimes we need it though, so see what your requirements are and proceed accordingly. Best of luck!

Upvotes: 3

Related Questions