कोड जनरेशन Clojure

Question

में

(अस्वीकरण:। मैं एक सी # पुरुष हूं मैं सिर्फ Clojure सीखने शुरू कर दिया है।)

मैं समझता हूँ कि एक Clojure कार्यक्रम ही में हेरफेर या आसानी से उत्पन्न करने के लिए अन्य कार्यक्रमों की क्षमता है । क्लोजर में डेटा संरचना होने के साथ इसमें कुछ करने के लिए कुछ है और प्रोग्राम उत्पन्न करना किसी अन्य प्रकार की डेटा संरचना बनाने जैसा ही होगा।

क्या किसी के पास एक अच्छा नमूना प्रोग्राम (या एक संदर्भ है) जो यह दिखाता है?

यदि आप प्रोग्राम उत्पन्न करते हैं, तो क्या आप उस प्रोग्राम को बाद में निष्पादन के लिए डिस्क पर "क्रमबद्ध" कर सकते हैं?

बस संदर्भ के लिए

:

1. मैं आनुवंशिक प्रोग्रामिंग के साथ खेलने के लिए कोशिश कर रहा हूँ। मैं बहुत सारे कार्यक्रम उत्पन्न करना चाहता हूं, उनका मूल्यांकन करना चाहता हूं, और अधिक कार्यक्रम उत्पन्न करने के लिए सफल लोगों का उपयोग करना चाहता हूं। अधिक here और here देखें।

2. मुझे लगता है कि मैं यहाँ शर्तों का दुरुपयोग कर रहा हूँ। प्रोग्राम मेरा वास्तव में एक क्लोजर सूची का मतलब है और कोड जनरेशन मेरा मतलब है "सूची जनरेशन"। मुझे वास्तविक फ़ंक्शन कॉल और पैरामीटर रखने के लिए केवल सूची की आवश्यकता है। जब यह सूची "निष्पादित" हो जाती है तो मुझे नियंत्रण करने में सक्षम होना चाहिए।

Answer 1

(+ 1 2) पर विचार करें। डेटा के रूप में, यह तीन वस्तुओं की एक लिंक की गई सूची है: प्रतीक + और दो इंटीग्रर्स। कोड के रूप में, यह एक फ़ंक्शन कॉल है, कह रहा है, "इन दो इंटीग्रियों के साथ + नामक फ़ंक्शन को कॉल करें और मुझे परिणाम दें"। आप इस सूची में कुछ भी कर सकते हैं जो आप डेटा की किसी भी अन्य सूची में कर सकते हैं। परिणाम प्राप्त करने के लिए आप भी कर सकते हैं।

user> (def x '(+ 1 2)) 
#'user/x 
user> (first x) 
+ 
user> (rest x) 
(1 2) 
user> (map class x) 
(clojure.lang.Symbol java.lang.Integer java.lang.Integer) 
user> (reverse x) 
(2 1 +) 
user> (concat x (rest x)) 
(+ 1 2 1 2) 
user> (eval x) 
3 
user> (defn foo [] 
     (let [ops '[+ - * /]    ; SO's lisp-highlighting sucks 
       nums (repeatedly #(rand-int 5)) 
       expr (list* (rand-elt ops) (take 10 nums))] 
      (prn expr) 
      (prn (eval expr)))) 
user> (foo) 
(+ 4 1 0 3 2 3 4 3 1 2) 
23 
nil 
user> (foo) 
(- 1 3 2 2 1 2 1 4 0 1) 
-15 
nil 

Answer 2

मिले this लेख में एक आंशिक जवाब:

pr और prn कार्यों उनके प्रिंट और println समकक्षों, की तरह हैं लेकिन उनके उत्पादन एक रूप है कि द्वारा पढ़ा जा सकता है क्लोजर रीडर। वे क्लोजर डेटा संरचनाओं को क्रमबद्ध करने के लिए उपयुक्त हैं। डिफ़ॉल्ट रूप से, वे प्रिंट मेटाडेटा नहीं करते हैं। यह true को विशेष प्रतीक *print-meta* बाध्यकारी द्वारा बदला जा सकता।

यह कम से कम मेरे प्रश्न के दूसरे भाग का उत्तर देता है।

Answer 3

मैक्रोज़ पर एक नज़र डालें। उदाहरण के लिए,

(defmacro defmacro- 
    "Same as defmacro but yields a private definition" 
    [name & decls] 
    (list* `defmacro (with-meta name (assoc (meta name) :private true)) decls)) 

मैक्रोज़ के साथ, आपको macroexpansion को क्रमबद्ध करने की आवश्यकता नहीं है; संकलन स्वचालित रूप से इसका उपयोग करेगा।

Answer 4

क्लोजर एक LISP है, और इसका मतलब है कि यह homoiconic भाषा है: डेटा और कोड के बीच कोई संरचनात्मक भेद नहीं है। इसकी सूची नीचे सभी तरह से है। इसमें एक एक्स्टेंसिबल कंपाइलर भी है जो आपको मैक्रोज़ के माध्यम से सिंटैक्स का विस्तार करने की अनुमति देता है। लेकिन यह आपकी समस्या कथन से स्पष्ट नहीं है कि आपको वास्तव में ऐसी चीज की आवश्यकता है।

आप मूल रूप से कोड चला रहे हैं जो सूचियां उत्पन्न करता है (जो वास्तव में अगले जीन प्रोग्राम हैं), उन्हें सहेजते हैं, और फिर नए प्रोग्राम चलाते हैं। जब तक आपके पीढ़ी के विकास के लिए नए वाक्यविन्यास की आवश्यकता नहीं होगी, तो आपको शायद मैक्रोज़ का सहारा लेने की आवश्यकता नहीं होगी।

Answer 5

प्रश्न कुछ हद तक भ्रामक है क्योंकि क्लोजर ऑन-द-फ्लाई "कोड पीढ़ी" भी करता है क्योंकि यह जावा बाइट कोड में क्लोजर स्रोत को संकलित करता है।

इस विशेष मामले में, मुझे विश्वास है कि आप विशेष रूप से लिस्प मैक्रोज़ में रूचि रखते हैं। मुझे लगता है कि इन दिलचस्प हो सकता है:

Clojure documentation itself

Video, Macros (in Clojure) in 20 minutes

Standard issue: Wikipedia - Clojure

ध्यान दें कि Clojure में मैक्रोज़ काम कॉमन लिस्प मैक्रो में किए गए बहुत समान (एक प्रकार -2 तुतलाना), और नहीं बहुत अधिक योजना मैक्रोज़ की तरह।

हैप्पी कोडिंग।