पासिंग Clojure

Question

में नेस्टेड मैक्रो के बीच संकलन समय राज्य मैं, ऐसा मैक्रो दोनों एक वैश्विक और नेस्टेड तरह से इस्तेमाल किया जा सकता है लिखने के लिए कोशिश कर रहा हूँ तो जैसे:

;;; global: 
(do-stuff 1) 

;;; nested, within a "with-context" block: 
(with-context {:foo :bar} 
    (do-stuff 2) 
    (do-stuff 3)) 

जब नेस्टेड तरह से इस्तेमाल किया, do-stuffwith-context द्वारा {:foo :bar} तक पहुंच होना चाहिए।

मैं इस तरह इसे लागू कर लिया है:

(def ^:dynamic *ctx* nil) 

(defmacro with-context [ctx & body] 
    `(binding [*ctx* ~ctx] 
    (do ~@body))) 

(defmacro do-stuff [v] 
    `(if *ctx* 
    (println "within context" *ctx* ":" ~v) 
    (println "no context:" ~v))) 

हालांकि, मैं संकलन-समय पर क्रम से do-stuff भीतर if शिफ्ट करने के लिए कोशिश कर रहा है, क्योंकि है कि क्या do-stuff के भीतर से बुलाया जा रहा है with-context का शरीर या वैश्विक रूप से एक ऐसी जानकारी है जो संकलन-समय पर पहले से ही उपलब्ध है।

दुर्भाग्य से, मैं, एक समाधान खोजने के लिए सक्षम नहीं किया गया है, क्योंकि नेस्टेड मैक्रो एकाधिक "मैक्रो विस्तार रन" में विस्तार करने के लिए लग रहे हैं तो गतिशील (with-context के भीतर निर्धारित रूप में) *ctx* के बंधन अब जब उपलब्ध नहीं है do-stuff विस्तारित हो जाता है। तो यह काम नहीं करता है:

(def ^:dynamic *ctx* nil) 

(defmacro with-context [ctx & body] 
    (binding [*ctx* ctx] 
    `(do ~@body))) 

(defmacro do-stuff [v] 
    (if *ctx* 
    `(println "within context" ~*ctx* ":" ~v) 
    `(println "no context:" ~v))) 

कोई विचार यह कैसे पूरा किया जाए?

या मेरा दृष्टिकोण पूरी तरह से पागल है और एक मैक्रो से घोंसले तक इस तरह से राज्य को कैसे पारित करने के लिए एक पैटर्न है?

संपादित:

with-context के शरीर न केवल do-stuff (या अन्य संदर्भ जागरूक कार्य/मैक्रो) के साथ, मनमाना भाव के साथ काम करने में सक्षम होना चाहिए। तो कुछ इस तरह भी संभव हो जाना चाहिए:

(with-context {:foo :bar} 
    (do-stuff 2) 
    (some-arbitrary-function) 
    (do-stuff 3)) 

(मुझे पता है some-arbitrary-function दुष्प्रभावों के बारे में है कि कर रहा हूँ, यह उदाहरण के लिए एक डेटाबेस के लिए कुछ लिख सकता है।)

Answer 1

जब कोड macroexpanded की जा रही है, Clojure computes एक fixpoint:

(defn macroexpand 
    "Repeatedly calls macroexpand-1 on form until it no longer 
    represents a macro form, then returns it. Note neither 
    macroexpand-1 nor macroexpand expand macros in subforms." 
    {:added "1.0" 
    :static true} 
    [form] 
    (let [ex (macroexpand-1 form)] 
     (if (identical? ex form) 
     form 
     (macroexpand ex)))) 

किसी भी आप किसी मैक्रो के निष्पादन के दौरान स्थापित बाध्यकारी कोई और अधिक जगह में है जब आप अपने मैक्रो से बाहर निकलेंगे (यह macroexpand-1 के अंदर होता है)। जब तक एक आंतरिक मैक्रो का विस्तार किया जा रहा है, संदर्भ लंबे समय से चला गया है।

लेकिन, आप सीधे macroexpand पर कॉल कर सकते हैं, इस स्थिति में बाध्यकारी अभी भी प्रभावी हैं। ध्यान दें कि आपके मामले में, आपको शायद macroexpand-all पर कॉल करने की आवश्यकता है। This answermacroexpand और clojure.walk/macroexpand-all के बीच अंतर बताता है: मूल रूप से, आपको यह सुनिश्चित करना होगा कि सभी आंतरिक रूप मैक्रोएक्सेंडेड हैं। macroexpand-all के लिए स्रोत कोड how it is implemented दिखाता है।

तो, आप अपने मैक्रो इस प्रकार लागू कर सकते हैं:

(defmacro with-context [ctx form] 
    (binding [*ctx* ctx] 
    (clojure.walk/macroexpand-all form))) 

उस मामले में, गतिशील बाइंडिंग भीतरी मैक्रो अंदर से दिखाई देना चाहिए।

Answer 2

मैं इसे सरल रखने चाहते हैं। यह समाधान अतिरिक्त *ctx* चर में राज्य से बचाता है। मुझे लगता है कि यह एक और अधिक कार्यात्मक दृष्टिकोण है।

(defmacro do-stuff 
    ([arg1 context] 
    `(do (prn :arg1 ~arg1 :context ~context)) 
     {:a 4 :b 5}) 
    ([arg1] 
    `(prn :arg1 ~arg1 :no-context))) 

(->> {:a 3 :b 4} 
    (do-stuff 1) 
    (do-stuff 2)) 

उत्पादन:

:arg1 1 :context {:a 3, :b 4} 
:arg1 2 :context {:b 5, :a 4} 

Answer 3

वहाँ यह करने के लिए एक और संस्करण है, कुछ मैक्रो जादू का उपयोग कर रहा है: इस परिभाषा में

(defmacro with-context [ctx & body] 
    (let [ctx (eval ctx)] 
    `(let [~'&ctx ~ctx] 
     (binding [*ctx* ~ctx] 
     (do ~@body))))) 

हम एक और letctx के लिए बाध्यकारी परिचय। क्लोजर की मैक्रो सिस्टम इसे &env वैरिएबल में रखेगी, संकलन-समय पर आंतरिक मैक्रोज़ द्वारा पहुंचा जा सकता है। ध्यान दें कि हम bindings भी रखते हैं ताकि आंतरिक कार्य इसका उपयोग कर सकें।

अब हम मैक्रो का &env से संदर्भ मूल्य प्राप्त करने के समारोह परिभाषित करने की जरूरत:

(defn env-ctx [env] 
    (some-> env ('&ctx) .init .eval)) 

और फिर आप आसानी से do-stuff परिभाषित कर सकते हैं:

user> (defn my-fun [] 
     (println "context in fn is: " *ctx*)) 
#'user/my-fun 

user> (defmacro my-macro [] 
     `(do-stuff 100)) 
#'user/my-macro 

user> (with-context {:a 10 :b 20} 
     (do-stuff 1) 
     (my-fun) 
     (my-macro) 
     (do-stuff 2)) 
;;within context {:a 10, :b 20} : 1 
;;context in fn is: {:a 10, :b 20} 
;;within context {:a 10, :b 20} : 100 
;;within context {:a 10, :b 20} : 2 
nil 

user> (do (do-stuff 1) 
      (my-fun) 
      (my-macro) 
      (do-stuff 2)) 
;;no context: 1 
;;context in fn is: nil 
;;no context: 100 
;;no context: 2 
nil 

:

(defmacro do-stuff [v] 
    (if-let [ctx (env-ctx &env)] 
    `(println "within context" ~ctx ":" ~v) 
    `(println "no context:" ~v))) 

repl में