कॉमन लिस्प के उदाहरण का उपयोग करके अपने निष्पादन के दौरान कार्यक्रम कोड को बदलना

परिचय

मेरी विनम्र राय में, लिस्प कार्यात्मक प्रोग्रामिंग भाषाओं में एक रत्न है। इस तथ्य के बावजूद कि यह उच्च-स्तरीय भाषाओं के इतिहास (1958) में से एक है, यह अभी भी विस्मित करना बंद नहीं करता है। मुझे ऐसा लगता है कि वह अपने समय से इतना आगे निकल चुका है कि उसका घंटा बस आने के लिए तैयार हो रहा है।

तो आइए एक प्रोग्राम लिखने की कोशिश करें जो अन्य भाषाओं में बनाने के लिए समस्याग्रस्त है। जैसा कि लेख का नाम है, यह कार्यक्रम निष्पादित होने के साथ ही अपने कोड को संपादित करेगा। इसे बनाने के लिए, मैं कॉमन लिस्प का उपयोग करता हूं, या इसके एसबीसीएल दुभाषिया का।


नोट: यदि आप शुद्ध एसबीसीएल लेते हैं, तो यह संपत्ति है कि प्रत्येक आउटपुट के बाद stdio स्ट्रीम को फ्लश न करें, मैं खुद Emacs और Slime के माध्यम से SBCL का उपयोग करता हूं, ऐसी कोई समस्या नहीं है। मुझे अभी तक पर्याप्त समाधान नहीं मिला है।

कैसे?

लिस्प में अद्भुत गुण हैं, जिनके बीच मैं कोड की बहुत ही सरल वाक्य रचना और एकरूपता को नोट करना चाहता हूं। सबसे अच्छी बात यह है कि कोई भी लिस्प कोड इसके लिए डेटा है, और कई डेटा कोड हो सकते हैं। विशेष रूप से, यह ऑटो-एपेरेटिव (खुद पर लागू) और ऑटो-रेप्लिकेटिव (खुद को पुन: प्रस्तुत करना) कार्यों को लिखना संभव बनाता है। उनके बारे में थोड़ा सा यहाँ लिखा गया है ; जानकारी, बदले में, "द वर्ल्ड ऑफ लिस्प" (ई। ह्यूवेन, आई। सेप्यानेन) खंड 1, पृष्ठ 280 से ली गई है। उदाहरण के लिए, क्वीन , जो कि ऑटो- ऐप्लिकेटिव और ऑटो-रेप्लिकेटिव दोनों है, इस तरह लिखा जाता है:

((lambda (x) (list x (list 'quote x))) '(lambda (x) (list x (list 'quote x)))) 

जब व्याख्या की जाती है, स्वाभाविक रूप से, यह स्वयं को घटाता है।
और ऐसा फ़ंक्शन क्यों नहीं लिखा जाता है जो खुद की एक सटीक प्रति नहीं देता है, लेकिन कुछ नए संस्करण, जो बाद में फिर से निष्पादित किए जाएंगे और भी अधिक उत्परिवर्तित संस्करण बनाने के लिए? तो चलिए करते हैं।

कमांड प्रोसेसर

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

सभी नमक यह होगा कि स्रोत (हर अर्थ में) कोड बहुत न्यूनतर होगा। जैसे ही हम इसे दुभाषिया को खिलाते हैं, हम अब REPL के साथ सीधे काम पर नहीं लौटेंगे। हमारे कार्यक्रमों को समय-समय पर हमारी टीमों के लिए निरंतर निष्पादित और विकसित (या नीचा) किया जाएगा।

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

 (defun start-program () '(lambda (program) (princ "$> ") (let ((input (read))) (when (listp input) (let ((command (car input))) (cond ((eq command 'code) ;   = code, (setf program ;    (funcall ;  ,    (eval (list 'lambda '(program input) (cadr input))) program input) ) ) (t (format t "Unknown command ~A ~%" command)) ) ) ) program ) ) ) 

हमारा सोर्स कोड बहुत कम जानता है। यह उपयोगकर्ता के लिए एक संकेत प्रदर्शित करता है, कीबोर्ड से एस-एक्सप्रेशन पढ़ता है, अगर यह एक सूची है, तो पहला तत्व कमांड का नाम है, बाकी इसके तर्क हैं। आउट-ऑफ-द-बॉक्स कमांड प्रोसेसर केवल एक ही "कोड" कमांड को संसाधित कर सकता है। यह कमांड अपना पहला तर्क लेता है और इससे प्रोग्राम और इनपुट के लिए लागू एक लंबो फंक्शन बनाता है। इतनी मेहनत क्यों? क्योंकि eval एक शून्य शाब्दिक वातावरण में अपनी गंदी चालें करता है, जिसका अर्थ है कि स्थानीय चर कार्यक्रम और इनपुट हमारे लिए उपलब्ध नहीं हैं, हालांकि उनकी आवश्यकता हो सकती है। हमें उन्हें बाहर निकालने के लिए एक रास्ता खोजने की आवश्यकता है; यह मेरे साथ घटित मापदंडों के साथ एक मेमने से बेहतर कुछ नहीं है। मैं बाहर नहीं करता हूं कि अधिक सुरुचिपूर्ण तरीके हैं। आंतरिक निष्कासन का परिणाम कार्यक्रम चर को सौंपा गया है। सामान्य तौर पर, हम केवल शेष इनपुट प्रोग्राम को असाइन कर सकते हैं, लेकिन इस मामले में हम कोड कमांड का उपयोग करते समय अतिरिक्त कार्य नहीं कर पाएंगे। उनके बारे में थोड़ी देर बाद।
निम्नलिखित मुख्य कार्य कार्यक्रम चक्र का आयोजन करता है। इसमें सभी जादू लुटाते हैं।

 (defun main () (let ((program (start-program))) ;    ; ,    , ..  nil (loop while program do ;  try - catch,   , ;      (handler-case ;   program   , ;    program   program (setf program (funcall (eval program) program)) ;   ,    (error (c1) (format t "Error! ~A~%" c1) ) ) ) ) ) 

इसलिए, प्रोग्राम (प्रोग्राम वेरिएबल) खाली होने तक लूप चालू रहता है। शून्य पुनरावृत्ति पर कार्यक्रम स्टार्ट-प्रोग्राम फ़ंक्शन का परिणाम है, और गैर-शून्य पुनरावृत्ति पर हम इसे (कार्यक्रम चर) कार्यक्रम पैरामीटर (फिर से) के साथ इसमें निहित फ़ंक्शन (प्रोग्राम चर) को निष्पादित करने का परिणाम है। यह एक तनातनी नहीं है, और यह समझना महत्वपूर्ण है कि आगे बढ़ने से पहले यह कैसे काम करता है। पता चला? अब REPL- मुख्य में चलाएं और प्रॉम्प्ट देखें:

 CL-USER> (main) $> 

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

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

 (code '(lambda (program) (princ "$> ") (let ((input (read))) (when (listp input) (let ((command (car input))) (cond ((eq command 'code) (setf program (funcall (eval (list 'lambda '(program input) (cadr input))) program input))) ((eq command 'eval) (eval (cadr input))) ;  (t (format t "Unknown command ~A ~%" command)) ) ) ) program ) ) ) 

शायद यह स्टाइल-चेतावनी दे देगा, यह डरावना नहीं है। की जाँच करें:

 $> (eval (print (+ 3 2))) 5 $> 

वोइला, यह काम करता है!
सीज़न सिस्टम तीन कार्यों (rsubs, rrem, rins) के साथ। rsubs (पुनरावर्ती प्रतिस्थापन) पुराने फॉर्म (पहले पैरामीटर पुराने) को नए (दूसरे पैरामीटर नए) के साथ फॉर्म (तीसरे पैरामीटर फॉर्म) में पुनरावृत्ति करता है। rrem (रिकर्सिव रिमूव) फॉर्म (किस का पहला पैरामीटर) फॉर्म से निकालता है (फॉर्म का दूसरा पैरामीटर) भी पुनरावर्ती है। अंत में, फार्म (तीसरे पैरामीटर फॉर्म) पर फॉर्म (दूसरा पैरामीटर क्या) के बगल में रिंस (पुनरावर्ती आवेषण) सम्मिलित करता है और यदि कुंजी निर्दिष्ट की जाती है: टी से पहले, तो इंसर्ट फॉर्म से पहले किया जाता है जहां, अन्यथा - इसके बाद - आपको तीन कमांड निष्पादित करने होंगे।


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

 (code (rins 'cond '((eq command 'view) (progn (format t "---code---") (print program) (terpri))) program)) 

हम परीक्षण कर रहे हैं, कुछ इस तरह से बाहर निकलना चाहिए:


बहुत बढ़िया! अब हमारे लिए एक टीम जोड़ना आसान है जो टीमों को जोड़ेगी। अच्छा, इसे और कैसे कहें? कमांड के लिए सिंटैक्स होगा: (ऐड-सीएमडी नाम-नया-कमांड what-she-will-do) । लेकिन यहां हम एक विकट स्थिति की प्रतीक्षा कर रहे हैं। पिछली बार हमने कंडोम परमाणु के बाद नई कमांड के लिए कोड डाला था, क्योंकि यह सबसे आसान था। यह नाम आम है, और यदि पाठ में इसका एक और उल्लेख दिखाई देता है, तो सम्मिलित रूप से वहां भी निष्पादित किया जाएगा, जो उन हिस्सों के संचालन को बाधित करेगा जिन्हें हम छूने नहीं जा रहे थे। इस समस्या को हल करने के कई तरीके हैं, उदाहरण के लिए, एक अद्वितीय मार्कर दर्ज करें और इसके बाद नए कमांड डालें। मार्कर एक असंभव स्थिति होगी जिसे हम कंडोम के बाद जोड़ते हैं:

 (code (rins 'cond '((eq t nil) 'secret-marker) program)) 

हो गया। अब हम इस मार्कर का उपयोग करके सम्मिलन स्थान को रिंस में स्थानांतरित करेंगे। मार्कर की भारीता का कोई मतलब नहीं है, क्योंकि हम एक टीम बनाएंगे जो इसे जान जाएगी, और हमें इसे याद रखने की आवश्यकता नहीं होगी। वैसे, ऐड-सीएमडी कमांड कोड मार्कर परिभाषा का उपयोग नहीं कर सकता है, अन्यथा रिंस इसे ढूंढ और तोड़ देगा। आप मार्कर को विकृत करके रिन्स को मूर्ख बनाने की कोशिश कर सकते हैं, लेकिन इसे केवल एक अलग बाहरी फ़ंक्शन में डालना आसान है (रिन्स उनके लिए नहीं दिखता है)। एड-कमांड-टू-प्रोग्राम फ़ंक्शन प्रोग्राम को पहले पैरामीटर के रूप में लेता है और इसे अद्यतन करता है, इसे जोड़ने से एक नया कमांड कमांड होता है जो कार्रवाई करता है:

 (eval (defun add-command-to-program (program command action) (rins '((eq t nil) 'secret-marker) ;   `((eq command ',command) ,action) ;   program ) ) ) 

वास्तव में ऐड-सीएमडी कमांड बनाएं।

 (code (rins '((eq t nil) 'secret-marker) ;     `((eq command 'add-cmd) ;    add-cmd (setf program (add-command-to-program program (cadr input) (caddr input))) ) program ) ) 

अद्भुत! अब नए आदेशों को जोड़ने से आसान कुछ नहीं है (उनमें से अंतिम दो अभी तक नहीं चलाने के लिए बेहतर हैं):

 (add-cmd hi (princ "Hi, ")) (add-cmd quit (setf program nil)) (add-cmd reset (setf program (start-program))) 

अधिक उपयोगी एक प्रोग्राम फ़ाइल को सहेजने और फिर इसे एक फ़ाइल से लोड करने की क्षमता होगी। उचित सहेजें और आदेशों को लोड करने को परिभाषित करें:

 (add-cmd save (with-open-file (stream (cadr input) :direction :output :if-exists :overwrite :if-does-not-exist :create) (print program stream))) (add-cmd load (setf program (with-open-file (stream (cadr input)) (read stream)))) 

अब हम अपनी उपलब्धियों को किसी भी टेक्स्ट फ़ाइल में सहेज सकते हैं और उन्हें वहां से लोड कर सकते हैं। लेकिन यह याद रखना चाहिए कि हम केवल कार्यक्रम की सामग्री को सहेजते हैं और लोड करते हैं; eval + defun कमांड द्वारा परिभाषित सभी फ़ंक्शन इन फ़ाइलों में संग्रहीत नहीं हैं, वे दुभाषिया की मेमोरी में संग्रहीत हैं। इस कष्टप्रद गलतफहमी को ठीक करना संभव है, लेकिन हम अब इस पर स्पर्श नहीं करेंगे।

 $> (save "1.txt") $> (load "1.txt") 

अनुकूलन

एक बदलाव के लिए हम अपने संवाद के अनुकूलन में लगे रहेंगे। उदाहरण के लिए, हम फ़ंक्शन के साथ मज़ेदार अभिवादन जोड़ते हैं:

 (eval (defun greeting () (let ((sentences (vector "My life for Ner'zhul. " "I wish only to serve. " "Thy bidding, master? " "Where shall my blood be spilled? " "I bow to your will. " ))) (elt sentences (random (length sentences))) ) ) ) 

अब उन्हें शेल में लागू करें:

 (code (rsubs '"$> " '(greeting) program)) 

आपको कुछ ऐसा मिलता है:

 I bow to your will. (hi) Hi, I wish only to serve. 

अंत में, मैं कुछ और अधिक जटिल के साथ (पढ़ें) को प्रतिस्थापित करके अतिरिक्त कोष्ठक से छुटकारा पाने का प्रस्ताव करता हूं: हम पंक्ति को पढ़ेंगे और इसे खुद को ब्रैकेट के साथ फ्रेम करेंगे।

 (code (rsubs '(read) '(read-from-string (concatenate 'string "(" (read-line) ")")) program)) 

परिणाम:

 Thy bidding, master? hi Hi, Where shall my blood be spilled? 

चलो अंत में फिर से कोड पर एक नज़र डालें:


इस चीज़ के साथ आप जितना चाहें उतना मज़े कर सकते हैं! लेकिन आज के लिए काफी है।