Speichern einer Destrukturierungskarte für die spätere Verwendung

Question

Ich habe versucht, dies mit Zitat, Zitat-Splicing, Eval und was auch immer ich denken kann, zu arbeiten, aber bisher kein Glück. Ich verstehe, warum es nicht funktioniert - es wird als eine Karte gesehen, und es versucht, a, b und c zu evalieren - einfach nicht, wie man es umgehen kann.

(def destructor {a :a b :b c :c}) 
; CompilerException java.lang.RuntimeException: Unable to resolve symbol: a in this context, compiling:(:1:15) 

(let [destructor my-map] 
    'etc) 

Ich habe eine ziemlich komplizierte Destrukturierung Karte, die ich verwende mehrmals unter Berücksichtigung, so schien es eine gute Idee, es irgendwo zu verstauen. Vielleicht gibt es bessere Möglichkeiten, das zu tun?

Answer 1

Gute Idee, aber Sie können es nicht auf diese Art tun, weil die Sache, die Sie speichern möchten, nicht wirklich ein Wert ist, also können Sie es nicht in einem var speichern.

Stattdessen können Sie ein Makro definieren, das in seiner Erweiterung umfasst:

(defmacro with-abc [abc & body] 
    `(let [~'{:keys [a b c]} ~abc] 
    ~@body)) 

(with-abc foo 
    (...use a, b, and c...)) 

Answer 2

So etwas wie @ amalloy Antwort war mein erster Instinkt zu und es ist wahrscheinlich der Weg zu gehen. Das heißt, es könnte eine einfache ol eine Überlegung wert‘Funktion höherer Ordnung:

(defn destruct 
    [{a :a b :b c :c} f] 
    (f a b c)) 

(destruct my-map 
      (fn [a b c] 
      (println a) 
      (println b) 
      (println c))) 

Es ist ein wenig neugieriger und du bist gezwungen, jedes Mal wenn die Bindungen zu nennen, aber Sie mögliche Hygieneprobleme vermeiden und je nach Ihr Komfort mit Metaprogrammierung, es ist ein wenig leichter zusammen zu stellen.

Answer 3

Sie müssen den zerstörenden Muster

(def my-destructor '{a :a b :b c :c}) 

Sie können dies mit Ebenen zu zitieren/unquoting zitieren, aber es ist einfacher, mit einer kleinen Hilfsfunktion zu sehen.

(defn- with-destructor* [binding & body] 
    `(let ~binding ~@body)) 

Diese eval tritt zu einer Zeit "kompiliert" (während der Makroerweiterung)

(defmacro with-destructor [[destructor form] & body] 
    (eval `(with-destructor* [~destructor '~form] '~@body))) 

Wie

gezeigt

(macroexpand-1 '(with-destructor [my-destructor {:a 1 :c 3}] (+ a c))) 
;=> (clojure.core/let [{a :a, b :b, c :c} {:a 1, :c 3}] (+ a c)) 

Ergebnis

(with-destructor [my-destructor {:a 1 :c 3}] (+ a c)) 
;=> 4