गतिशील रूप से बनाए गए नेमस्पेस में फ़ंक्शंस जोड़ने का कोई साफ तरीका है?

Question

मैं एक नोयर वेबपैप बना रहा हूं, और मुझे गतिशील रूप से नए विचार और मॉडल बनाने की आवश्यकता है। मैं नोयर उदाहरणों का पालन कर रहा हूं, जिसमें संसाधन के लिए दृश्य और नियंत्रक के पास अलग-अलग नामस्थान हैं, और मैंने इसे एक बहुत ही साफ दृष्टिकोण पाया है।

इसके साथ में, मुझे गतिशील रूप से दृश्यों और मॉडलों के अनुरूप नए नामस्थान बनाने में सक्षम होना चाहिए, और उसके बाद उचित कार्यों को प्रशिक्षित करना होगा। मेरा विचार था कि मैक्रोज़ को एक अलग नेमस्पेस में निर्दिष्ट किया गया था, जिसे नए नामस्थान में बुलाया जाने पर उचित मार्ग/आंशिक/जो कुछ भी प्रदान किया जाएगा।

उदाहरण के लिए (मेरी पहली defmacro माफ):

(ns project.views.proto 
    (:use noir.core 
     hiccup.core 
     hiccup.element 
     hiccup.form)) 

(defmacro def-all-page 
    [path] 
    `(defpage ~path [] 
    (html 
     [:h1 "Ya'll here"]))) 

से कहा जाता है ...

(ns project.proto 
    (:use [clojure.contrib.with-ns :only [with-ns]]) 

(create-ns 'foo) 
(intern 'foo 'path "path") ; In reality, the path is dynamic which is why I intern it 
(with-ns 'foo 
    (clojure.core/refer-clojure) 
    (use 'noir.core 
     'hiccup.core 
     'hiccup.element 
     '[project.views.proto :only [def-all-page]]) 

    (def-all-page path) 

हालांकि, मेरी नई नाम स्थान के भीतर से इस बुला मुझे एक NullPointerException देता है। मैं किसी भी मदद की सराहना करता हूं, और बेहतर दृष्टिकोण है या नहीं। जैसे, बस एक नामस्थान के लिए संदर्भ का उपयोग जिसमें सभी आवश्यक परिभाषाएं शामिल हैं?

पहला पोस्ट, और मुझे नहीं लगता कि यह this का दोहराव है। धन्यवाद!

Answer 1

सबसे पहले, यह प्रश्न थोड़ा पुराना हो गया है। पिछले साल नोएर और क्लोजर दोनों विकसित हुए हैं। स्पष्टता के लिए मैं समीकरण से नोएर ले जाऊंगा और मैक्रोज़ का उपयोग करके गतिशील रूप से कार्यों को बनाने के बारे में आपके प्रश्न का उत्तर देने का प्रयास करूंगा।

आरईपीएल पर साथ पालन करें:

$ lein repl 
user=> (in-ns 'foo) 
#<Namespace foo> 
foo=> (clojure.core/refer-clojure) 
nil 
foo=> (defmacro say-hello-to 
#_=>   [name] 
#_=>   `(defn ~(symbol (str "hello-" name)) 
#_=>     [] 
#_=>     ~(str "hello: " name))) 
#'foo/say-hello-to 

यहाँ हम एक namespace 'foo' है कि परिभाषित करने 'हैलो-yourname' कार्यों के लिए एक मैक्रो शामिल पैदा करते हैं। चलो एक और नाम स्थान बनाएँ:

foo=> (in-ns 'bar) 
#<Namespace bar> 
bar=> (clojure.core/refer-clojure) 
nil 
bar=> (refer 'foo :only '[say-hello-to]) 
nil 
bar=> (say-hello-to "tom") 
#'bar/hello-tom 
bar=> (say-hello-to "jerry") 
#'bar/hello-jerry 

करते हैं अगर इन वास्तव में काम देखते हैं:

bar=> (hello-tom) 
"hello: tom" 
bar=> (hello-jerry) 
"hello: jerry" 

मुझे लगता है कि यह बहुत अपने मूल उदाहरण के करीब है।

आशा है कि इससे मदद मिलती है!