आम लिस्प के लाभ

लिस्प को अक्सर एक ऐसी भाषा के रूप में जाना जाता है जिसमें दूसरों पर लाभ होता है क्योंकि इसमें कुछ अनोखी, अच्छी तरह से एकीकृत और उपयोगी विशेषताएं होती हैं।

निम्नलिखित मानक कॉमन लिस्प की सुविधाओं के एक समूह को संक्षिप्त रूप से और उदाहरणों के साथ उजागर करने का प्रयास है।

यह आलेख उन लोगों के लिए सबसे उपयोगी होने की संभावना है जिनके पास कुछ प्रोग्रामिंग अनुभव है, लिस्प में रुचि रखते हैं और बेहतर ढंग से समझना चाहते हैं कि यह कितना आकर्षक बनाता है।

पाठ सीएल सुविधाओं की सूची और रॉबर्ट स्ट्रैंड्ह की सीएल समीक्षा पर आधारित है।

समृद्ध और सटीक अंकगणित

लिस्प नंबर प्रकारों की एक समृद्ध पदानुक्रम प्रदान करता है जो बाकी भाषा के साथ अच्छी तरह से एकीकृत होते हैं।

लंबी संख्या (bignums) स्वचालित रूप से आवश्यकतानुसार बनाई जाती है, जो ओवरफ्लो के जोखिम को कम करती है और सटीकता सुनिश्चित करती है। उदाहरण के लिए, हम जल्दी से मूल्य 10, 4 की गणना कर सकते हैं:

> (expt (expt (expt (expt 10 10) 10) 10) 10) 100000000000000000000000000000000000[...] 

परिमेय संख्याओं को भिन्नों के रूप में दर्शाया जाता है, ताकि उनका उपयोग करते समय कोई गोल त्रुटि न हो। सटीक तर्कसंगत अंकगणित को भाषा में एकीकृत किया गया है:

 > (+ 5/9 3/4) 47/36 

कॉम्प्लेक्स नंबर भी लिस्ट में एक अंतर्निहित डेटा प्रकार है। उन्हें एक छोटे वाक्यविन्यास के रूप में दर्शाया जा सकता है: #c (10 5) का अर्थ है 10 + 5i। अंकगणितीय ऑपरेशन भी जटिल मूल्यों के साथ काम कर सकते हैं:

 > (* 2 (+ #c(10 5) 4)) #C(28 10) 

सामान्यीकृत लिंक

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

उदाहरण के लिए, आप SETF का उपयोग इस प्रकार कर सकते हैं:

 > (defvar *colours* (list 'red 'green 'blue)) *COLOURS* > (setf (first *colours*) 'yellow) YELLOW > *colours* (YELLOW BLUE GREEN) 

और PUSH इस तरह है:

 > (push 'red (rest *colours*)) (RED BLUE GREEN) > *colours* (YELLOW RED BLUE GREEN) 

सामान्य लिंक न केवल सूचियों पर लागू होने पर, बल्कि कई अन्य प्रकार की संरचनाओं और वस्तुओं पर भी काम करते हैं। उदाहरण के लिए, ऑब्जेक्ट-ओरिएंटेड प्रोग्राम्स में, ऑब्जेक्ट के कुछ फ़ील्ड को बदलने के तरीकों में से एक SETF का उपयोग कर रहा है।

एकाधिक मूल्य

मानों को स्पष्ट रूप से एक सूची जैसे संरचना बनाए बिना जोड़ा जा सकता है। उदाहरण के लिए, (मान 'फू' बार) दो मान लौटाता है - 'फू और बार'। इस तंत्र का उपयोग करके, फ़ंक्शन एक साथ कई मान लौटा सकते हैं, जो कार्यक्रम को सरल बना सकते हैं।

उदाहरण के लिए, FLOOR एक मानक फ़ंक्शन है जो दो मान लौटाता है:

 > (floor pi) 3 0.14159265358979312d0 

सम्मेलन द्वारा, कई मान लौटाने वाले फ़ंक्शन डिफ़ॉल्ट रूप से उपयोग किए जाते हैं जैसे कि केवल एक मान लौटाया गया था - पहला।

 > (+ (floor pi) 2) 5 

ऐसा करने में, आप बाकी मूल्यों को स्पष्ट रूप से प्राप्त और उपयोग कर सकते हैं। निम्नलिखित उदाहरण में, हम गोल करते समय PI के पूर्णांक और भिन्नात्मक भागों को अलग करते हैं:

 > (multiple-value-bind (integral fractional) (floor pi) (+ integral fractional)) 3.141592653589793d0 

मैक्रो

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

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

इससे लिस्प में डोमेन-विशिष्ट भाषाओं (डीएसएल) को एम्बेड करना आसान हो जाता है, क्योंकि प्रोग्राम चलाने से पहले भाषा में विशेष वाक्यविन्यास जोड़ा जा सकता है।

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

मैक्रो LOOP

लूप मैक्रो लूप का प्रतिनिधित्व करने के लिए एक शक्तिशाली उपकरण है। वास्तव में, यह पुनरावृत्त प्रक्रियाओं का वर्णन करने के लिए एक पूरी छोटी अंतर्निहित भाषा है। LOOP लूप लिखने के लिए सभी आवश्यक प्रकार के भाव प्रदान करता है, सरल पुनरावृत्ति से लेकर पुनरावृत्तियों और जटिल राज्य मशीनों तक।

 > (defvar *list* (loop :for x := (random 1000) :repeat 5 :collect x)) *LIST* > *list* (324 794 102 579 55) 

 > (loop :for elt :in *list* :when (oddp elt) :maximizing elt) 579 

 > (loop :for elt :in *list* :collect (log elt) :into logs :finally (return (loop :for l :in logs :if (> l 5.0) :collect l :into ms :else :collect l :into ns :finally (return (values ms ns))))) (5.7807436 6.6770835 6.3613024) (4.624973 4.0073333) 

FORMAT फ़ंक्शन

FORMAT फ़ंक्शन यह बताने के लिए एक एम्बेडेड भाषा का समर्थन करता है कि डेटा को कैसे स्वरूपित किया जाना चाहिए। सरल पाठ प्रतिस्थापन के अलावा, FORMAT निर्देश पाठ को उत्पन्न करने के लिए एक कॉम्पैक्ट रूप में विभिन्न नियम व्यक्त कर सकते हैं, जैसे कि स्थिति, लूप, और सीमा मामलों को संभालना।

हम इस फ़ंक्शन का उपयोग करके नामों की सूची को प्रारूपित कर सकते हैं:

 (defun format-names (list) (format nil "~{~:(~a~)~#[.~; and ~:;, ~]~}" list)) 

 > (format-names '(doc grumpy happy sleepy bashful sneezy dopey)) "Doc, Grumpy, Happy, Sleepy, Bashful, Sneezy and Dopey." > (format-names '(fry laurie)) "Fry and Laurie." > (format-names '(bluebeard)) "Bluebeard." 

FORMAT अपना परिणाम निर्दिष्ट स्ट्रीम में स्थानांतरित करता है, चाहे वह स्क्रीन, एक स्ट्रिंग या किसी अन्य स्ट्रीम के लिए मानक आउटपुट हो।

उच्च आदेश कार्य

लिस्प में कार्य वास्तविक प्रथम श्रेणी की इकाइयाँ हैं। कार्यात्मक वस्तुओं को गतिशील रूप से बनाया जा सकता है, मापदंडों के रूप में पारित किया जा सकता है, या परिणामस्वरूप वापस आ सकता है। इस प्रकार, उच्च-क्रम के कार्यों का समर्थन किया जाता है, अर्थात, जिनके तर्क और वापसी मूल्य स्वयं कार्य हो सकते हैं।

यहां आप SORT फ़ंक्शन को कॉल करते हैं, जिसके तर्क एक सूची और दूसरे फ़ंक्शन हैं (इस मामले में, # '<):

 > (sort (list 4 2 3 1) #'<) (1 2 3 4) 

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

इस उदाहरण में, हम इसे MAPCAR के पहले तर्क के रूप में उपयोग करने के लिए एक अनाम फ़ंक्शन बनाते हैं:

 > (mapcar (lambda (x) (+ x 10)) '(1 2 3 4 5)) (11 12 13 14 15) 

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

 (let ((counter 10)) (defun add-counter (x) (prog1 (+ counter x) (incf counter)))) 

 > (mapcar #'add-counter '(1 1 1 1)) (11 12 13 14) > (add-counter 50) 64 

सूची प्रसंस्करण

चूंकि लिस्प में मूलभूत अंतर्निहित डेटा प्रकार हैं, इसलिए सूचियों में हेरफेर करने के लिए कार्यों का एक व्यापक सेट है। ऐसे कार्यों और मैक्रोज़ के लिए धन्यवाद, सूचियों का उपयोग अन्य डेटा संरचनाओं को जल्दी से प्रोटोटाइप करने के लिए किया जा सकता है।

उदाहरण के लिए, हम एक नियमित सूची के साथ इस तरह काम कर सकते हैं:

 > (defvar *nums* (list 0 1 2 3 4 5 6 7 8 9 10 11 12)) *NUMS* > (list (fourth *nums*) (nth 8 *nums*)) (3 8) > (list (last *nums*) (butlast *nums*)) ((12) (0 1 2 3 4 5 6 7 8 9 10 11)) > (remove-if-not #'evenp *nums*) (0 2 4 6 8 10 12) 

और इसलिए - साहचर्य सूची के साथ

 > (defvar *capital-cities* '((NZ . Wellington) (AU . Canberra) (CA . Ottawa))) *CAPITAL-CITIES* > (cdr (assoc 'CA *capital-cities*)) OTTAWA > (mapcar #'car *capital-cities*) (NZ AU CA) 

लंबोदर सूची

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

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

निम्न फ़ंक्शन वैकल्पिक सीमांकक पैरामीटर को स्वीकार करता है, जिसका डिफ़ॉल्ट मान एक व्हाट्सएप वर्ण है:

 (defun explode (string &optional (delimiter #\Space)) (let ((pos (position delimiter string))) (if (null pos) (list string) (cons (subseq string 0 pos) (explode (subseq string (1+ pos)) delimiter))))) 

EXPLODE फ़ंक्शन को कॉल करते समय, हम या तो एक वैकल्पिक पैरामीटर प्रदान कर सकते हैं या इसे छोड़ सकते हैं।

 > (explode "foo, bar, baz" #\,) ("foo " " bar " " baz") 

 > (explode "foo, bar, baz") ("foo," "bar," "baz") 

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

उदाहरण के लिए, इन दो फ़ंक्शन कॉल की तुलना करें:

 // In C: xf86InitValuatorAxisStruct(device, 0, 0, -1, 1, 0, 1); 

 ;; In Lisp: (xf86-init-valuator-axis-struct :dev device :ax-num 0 :min-val 0 :max-val -1 :min-res 0 :max-res 1 :resolution 1) 

प्रथम श्रेणी के निकाय के रूप में प्रतीक

प्रतीक अद्वितीय वस्तुएं हैं जो पूरी तरह से उनके नामों से परिभाषित होती हैं। कहो, 'फू एक पात्र है जिसका नाम "FOO" है। प्रतीकों का उपयोग पहचानकर्ता या कुछ अमूर्त नामों के रूप में किया जा सकता है। चरित्र की तुलना एक निश्चित समय में होती है।

फ़ंक्शंस, जैसे प्रतीक, प्रथम श्रेणी के निकाय हैं। उन्हें गतिशील रूप से बनाया जा सकता है, उद्धृत किया जा सकता है (उद्धरण, अवमूल्यन), संग्रहीत, तर्क के रूप में पारित किया गया, तुलना की गई, तार में परिवर्तित किया गया, निर्यात किया गया और आयात किया गया, उन्हें संदर्भित किया जा सकता है।

यहाँ '* foo *' वेरिएबल की पहचानकर्ता है:

 > (defvar *foo* 5) *FOO* > (symbol-value '*foo*) 5 

प्रथम श्रेणी संस्थाओं के रूप में पैकेज

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

निम्नलिखित उदाहरण में, हम कुछ पैकेज में एक चरित्र को शामिल करने के लिए आंतरिक का उपयोग करते हैं:

 > (intern "ARBITRARY" (make-package :foo :use '(:cl))) FOO::ARBITRARY NIL 

लिस्प में एक विशेष चर * पैकेज * है जो वर्तमान पैकेज को इंगित करता है। मान लीजिए कि यदि वर्तमान पैकेज FOO है, तो आप चला सकते हैं:

 > (in-package :foo) #<PACKAGE "FOO"> > (package-name *package*) "FOO" 

विशेष चर

लिस्प शाब्दिक संदर्भ के अलावा चर के गतिशील संदर्भ का समर्थन करता है। गतिशील चर कुछ मामलों में उपयोगी हो सकते हैं, इसलिए उनका समर्थन अधिकतम लचीलेपन की अनुमति देता है।

उदाहरण के लिए, हम कुछ कोड के आउटपुट को एक गैर-मानक स्ट्रीम में पुनर्निर्देशित कर सकते हैं, जैसे कि एक फ़ाइल, विशेष चर * मानक-आउटपुट * के लिए एक गतिशील लिंक बना रहा है:

 (with-open-file (file-stream #p"somefile" :direction :output) (let ((*standard-output* file-stream)) (print "This prints to the file, not stdout.")) (print "And this prints to stdout, not the file.")) 

* मानक-आउटपुट * के अलावा, लिस्प में कई विशेष चर शामिल होते हैं जो प्रोग्राम की स्थिति को संग्रहीत करते हैं, जिसमें संसाधन और पैरामीटर शामिल हैं, जैसे कि * मानक-इनपुट *, * पैकेज *, * पठनीय *, * प्रिंट-पठनीय *, * प्रिंट-सर्कल *। आदि

नियंत्रण स्थानांतरण

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

नामित ब्लॉक BLOCK और RETURN-FROM का उपयोग करके किसी भी नामांकित माता-पिता के फ़ॉर्म से नियंत्रण वापस करने की अनुमति देता है।

उदाहरण के लिए, यहां नेस्टेड लूप बाहरी ब्लॉक को दरकिनार करते हुए प्रारंभिक ब्लॉक से एक सूची देता है:

 > (block early (loop :repeat 5 :do (loop :for x :from 1 :to 10 :collect x :into xs :finally (return-from early xs)))) (1 2 3 4 5 6 7 8 9 10) 

कैच / थ्रो एक गैर-स्थानीय गोटो जैसा कुछ होता है। THROW अंतिम CATCH से कूदता है और उस मान को पास करता है जिसे एक पैरामीटर के रूप में निर्दिष्ट किया गया था।

पिछले उदाहरण के आधार पर, THROW-RANGE फ़ंक्शन में, हम प्रोग्राम की गतिशील स्थिति का उपयोग करके THROW और CATCH को लागू कर सकते हैं।

 (defun throw-range (ab) (loop :for x :from a :to b :collect x :into xs :finally (throw :early xs))) 

 > (catch :early (loop :repeat 5 :do (throw-range 1 10))) (1 2 3 4 5 6 7 8 9 10) 

जब यह शाब्दिक गुंजाइश का उपयोग करने और पकड़ने / फेंकने के लिए पर्याप्त है, जब गतिशील स्थिति को ध्यान में रखना आवश्यक है।

स्थितियां फिर से शुरू होती हैं

लिस्प में स्थितियों की प्रणाली एक कार्यक्रम के कुछ हिस्सों के बीच संकेतों को प्रसारित करने के लिए एक तंत्र है।

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

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

एक शर्त प्रणाली का उपयोग करने का एक उदाहरण लेख कॉमन लिस्प: ए ट्यूटोरियल ऑन कंडीशन एंड रिस्टार्ट्स में देखा जा सकता है।

सामान्यीकृत कार्य

सामान्य लिस्प ऑब्जेक्ट सिस्टम (कॉमन लिस्प ऑब्जेक्ट सिस्टम, सीएलओएस) कक्षाओं के तरीकों को नहीं बांधता है, लेकिन सामान्यीकृत कार्यों के उपयोग की अनुमति देता है।

सामान्य कार्य ऐसे हस्ताक्षरों को परिभाषित करते हैं जो कई अलग-अलग तरीकों से संतुष्ट कर सकते हैं। जब आह्वान किया जाता है, तो वह विधि जो तर्कों से सर्वश्रेष्ठ रूप से मेल खाती है

यहां हम एक सामान्यीकृत फ़ंक्शन को परिभाषित करते हैं जो कीबोर्ड से घटनाओं को संसाधित करता है:

 (defgeneric key-input (key-name)) 

फिर हम कई तरीकों को परिभाषित करते हैं जो विभिन्न KEY-NAME मानों को पूरा करते हैं।

 (defmethod key-input (key-name) ;; Default case (format nil "No keybinding for ~a" key-name)) (defmethod key-input ((key-name (eql :escape))) (format nil "Escape key pressed")) (defmethod key-input ((key-name (eql :space))) (format nil "Space key pressed")) 

आइए कार्रवाई में विधि कॉल को देखें:

 > (key-input :space) "Space key pressed" > (key-input :return) "No keybinding for RETURN" > (defmethod key-input ((key-name (eql :return))) (format nil "Return key pressed")) > (key-input :return) "Return key pressed" 

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

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

लिस्प कई उपयोगी मानक सामान्य कार्य प्रदान करता है; एक उदाहरण PRINT-OBJECT है, जो किसी भी वर्ग के लिए उसके पाठ्य प्रतिनिधित्व को परिभाषित करने के लिए विशिष्ट हो सकता है।

विधि संयोजन

विधियों के संयोजन आपको किसी विधि को कॉल करते समय तरीकों की एक पूरी श्रृंखला को निष्पादित करने की अनुमति देते हैं, या तो कुछ क्रम में, या इसलिए कि कुछ फ़ंक्शन दूसरों के परिणामों को संसाधित करते हैं।

किसी दिए गए क्रम में विधियों को व्यवस्थित करने के तरीकों के संयोजन के लिए अंतर्निहित तरीके हैं। कीवर्ड के साथ प्रदान किए गए तरीके: पहले ,: बाद, या: चारों ओर कॉल श्रृंखला में उचित स्थान पर रखे गए हैं।

उदाहरण के लिए, पिछले उदाहरण में, KEY-INPUT विधियों में से प्रत्येक वाक्यांश "कुंजी दबाया" के आउटपुट को दोहराता है। हम कोड को एक संयोजन के साथ सुधार सकते हैं जैसे: आसपास

 (defmethod key-input :around (key-name) (format nil "~:(~a~) key pressed" (call-next-method key-name))) 

उसके बाद, हम कुंजी-विधि को फिर से परिभाषित करेंगे, उनमें से प्रत्येक में केवल एक पंक्ति निर्दिष्ट करेंगे:

 (defmethod key-input ((key-name (eql :escape))) "escape") 

जब KEY-INPUT पर कॉल किया जाता है, तो निम्न होता है:

• एक विधि को एक लेबल के साथ कहा जाता है: चारों ओर
• यह निम्नलिखित विधि को कॉल करता है, जो कि KEY-INPUT के विशेष संस्करणों में से एक है,
• जो एक स्ट्रिंग लौटाता है, और यह स्ट्रिंग इस पद्धति को इसके आसपास प्रारूपित करती है।

यह ध्यान दिया जाना चाहिए कि डिफ़ॉल्ट विकल्प को अलग तरीके से संभाला जा सकता है। हम केवल THROW / CATCH जोड़ी का उपयोग कर सकते हैं (एक अधिक उन्नत कार्यान्वयन शर्तों का उपयोग कर सकता है):

 (defmethod key-input (key-name) (throw :default (format nil "No keybinding for ~a" key-name))) (defmethod key-input :around (key-name) (catch :default (format nil "~:(~a~) key pressed" (call-next-method key-name)))) 

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

एकाधिक वंशानुक्रम

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

विधियों, एक मेटा-ऑब्जेक्ट प्रोटोकॉल और अन्य सीएलओएस विशेषताओं के संयोजन का उपयोग करके, आप पारंपरिक कई विरासत समस्याओं (जैसे कांटा-जुड़ाव) को बायपास कर सकते हैं।

मेटाबोजेक्ट प्रोटोकॉल

मेटा-ऑब्जेक्ट प्रोटोकॉल (MOP) एक CLOS प्रोग्रामिंग इंटरफ़ेस है जो स्वयं CLOS का उपयोग करके कार्यान्वित किया जाता है। MOP प्रोग्रामर्स को CLOS के माध्यम से ही आंतरिक CLOS डिवाइस के अनुसंधान, उपयोग और संशोधन की क्षमता देता है।

प्रथम श्रेणी के निकाय के रूप में कक्षाएं

वर्ग स्वयं भी वस्तु हैं। एमओपी का उपयोग करके, आप कक्षाओं की परिभाषा और व्यवहार को बदल सकते हैं।

FOO वर्ग को BAR वर्ग का वंशज होने दें, फिर हम BAO वर्ग को FOO पूर्वजों की सूची में जोड़ने के लिए ENSURE-CLASS फ़ंक्शन का उपयोग कर सकते हैं:

 (defclass bar () ()) (defclass foo (bar) ()) (defclass baz () ()) 

 > (class-direct-superclasses (find-class 'foo)) (#<STANDARD-CLASS BAR>) > (ensure-class 'foo :direct-superclasses '(bar baz)) #<STANDARD-CLASS FOO> > (class-direct-superclasses (find-class 'foo)) (#<STANDARD-CLASS BAR> #<STANDARD-CLASS BAZ>) 

हमने कक्षा के पूर्वजों के बारे में जानकारी प्राप्त करने के लिए CLASS-DIRECT-SUPERCLASSES फ़ंक्शन का उपयोग किया; इस मामले में, यह FIND-CLASS से प्राप्त एक वस्तु के रूप में एक तर्क के रूप में एक वर्ग लेता है।

उपरोक्त उदाहरण उस तंत्र को दिखाता है जिसके द्वारा कक्षाओं को कार्यक्रम निष्पादन के दौरान संशोधित किया जा सकता है, जो अन्य चीजों के साथ, वर्गों के मिश्रण को गतिशील रूप से जोड़ने की अनुमति देता है।

गतिशील ओवरराइड करता है

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

इसलिए, यदि आप कार्यक्रम के निष्पादन के दौरान एक वर्ग को फिर से परिभाषित करते हैं, तो परिवर्तन तुरंत इस वर्ग के सभी ऑब्जेक्ट और उपवर्गों पर लागू हो जाएंगे। हम एक त्रिज्या संपत्ति और उसके उपवर्ग TENNIS-BALL के साथ एक वर्ग को परिभाषित कर सकते हैं:

 > (defclass ball () ((%radius :initform 10 :accessor radius))) #<STANDARD-CLASS BALL> > (defclass tennis-ball (ball) ()) #<STANDARD-CLASS TENNIS-BALL> 

यहाँ TENNIS-BALL वर्ग की एक वस्तु है, इसमें त्रिज्या संपत्ति के लिए एक स्लॉट है:

 > (defvar *my-ball* (make-instance 'tennis-ball)) *MY-BALL* > (radius *my-ball*) 10 

और अब हम इसमें एक और वॉल्यूम स्लॉट जोड़कर BALL क्लास को ओवरराइड कर सकते हैं:

 > (defclass ball () ((%radius :initform 10 :accessor radius) (%volume :initform (* 4/3 pi 1e3) :accessor volume))) #<STANDARD-CLASS BALL> 

और * MY-BALL * स्वचालित रूप से एक नया स्लॉट प्राप्त करने के लिए अपडेट किया गया, जिसे पूर्वज वर्ग में परिभाषित किया गया था।

 > (volume *my-ball*) 4188.790204786391d0 

रन टाइम पर कंपाइलर तक पहुंच

कम्पाइल और कम्पाइल-फ़ाइल फ़ंक्शंस के लिए धन्यवाद, लिस्प कंपाइलर का उपयोग सीधे निष्पादन योग्य प्रोग्राम से किया जा सकता है। इस प्रकार, प्रोग्राम चलने के दौरान बनाए जाने वाले या बदले गए कार्यों को भी संकलित किया जा सकता है।

यह पता चला है कि कार्यक्रमों को चरणों में संकलित किया जा सकता है, जो विकास को इंटरैक्टिव, गतिशील और तेज बनाता है। लॉन्च किए गए प्रोग्राम बदल सकते हैं, डिबग कर सकते हैं और धीरे-धीरे बढ़ सकते हैं।

संकलन मैक्रों

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

परिभाषाएँ टाइप करें

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

उदाहरण के लिए, हम अपने EXPLODE फ़ंक्शन में पैरामीटर प्रकारों को इस तरह परिभाषित कर सकते हैं:

 (defun explode (string &optional (delimiter #\Space)) (declare (type character delimiter) (type string string)) ...) 

प्रोग्राम करने योग्य पार्सर

लिस्प पार्सर इनपुट डेटा को पार्स करना आसान बनाता है। यह इनपुट स्ट्रीम से टेक्स्ट प्राप्त करता है और लिस्प ऑब्जेक्ट बनाता है, जिसे आमतौर पर एस-एक्सप्रेशन कहा जाता है। यह इनपुट डेटा के विश्लेषण को बहुत सरल करता है।

Parser का उपयोग कई कार्यों के माध्यम से किया जा सकता है, जैसे READ, READ-CHAR, READ-LINE, READ-FROM-STRING, आदि। इनपुट स्ट्रीम एक फ़ाइल, कीबोर्ड इनपुट और इसी तरह हो सकती है, लेकिन इसके अलावा, हम उचित फ़ंक्शन का उपयोग करके वर्णों के तार या अनुक्रम से डेटा पढ़ सकते हैं।

यहां READ-FROM-STRING का उपयोग करके पढ़ने का सबसे सरल उदाहरण है, जो एक ऑब्जेक्ट (400 500 600) बनाता है, अर्थात, स्ट्रिंग से एक सूची "(400 500 600)"।

 > (read-from-string "(400 500 600)") (400 500 600) 13 > (type-of (read-from-string "t")) BOOLEAN 

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

कुछ मानक पढ़ने मैक्रो:

• # # फू - फ़ंक्शंस,
• # \ _- अक्षर (अक्षर),
• # सी (4 3) - जटिल संख्या,
• # पी "/ पथ /" - फ़ाइल पथ।

पार्सर किसी भी वस्तु को उत्पन्न कर सकता है जिसके लिए पढ़ने के नियमों को परिभाषित किया गया है; विशेष रूप से, ये नियम रीड मैक्रोज़ का उपयोग करके सेट किया जा सकता है। वास्तव में, प्रश्न में पार्सर का उपयोग इंटरएक्टिव इंटरप्रिटर्स (रीड-इवल-प्रिंट लूप, आरईपीएल) के लिए भी किया जाता है।

यह हम मानक रीड मैक्रो का उपयोग करके हेक्साडेसिमल नोटेशन में संख्या पढ़ सकते हैं:

 > (read-from-string "#xBB") 187 

प्रोग्राम करने योग्य मुद्रण

लिस्प में पाठ आउटपुट सिस्टम एक अलग रूप में संरचनाओं, वस्तुओं या किसी अन्य डेटा को प्रिंट करने की क्षमता प्रदान करता है।

PRINT-OBJECT एक बिल्ट-इन सामान्यीकृत फ़ंक्शन है जो एक ऑब्जेक्ट और एक स्ट्रीम को तर्क के रूप में लेता है, और संबंधित विधि स्ट्रीम में दिए गए ऑब्जेक्ट का एक टेक्स्ट प्रतिनिधित्व प्रस्तुत करता है। किसी भी मामले में, जब आपको ऑब्जेक्ट के एक पाठीय प्रतिनिधित्व की आवश्यकता होती है, तो इस फ़ंक्शन का उपयोग किया जाता है, जिसमें FORMAT, PRINT और REPL शामिल हैं।

जौनी वर्ग पर विचार करें:

 (defclass journey () ((%from :initarg :from :accessor from) (%to :initarg :to :accessor to) (%period :initarg :period :accessor period) (%mode :initarg :mode :accessor mode))) 

अगर हम JOURNEY वर्ग की एक वस्तु को प्रिंट करने का प्रयास करते हैं, तो हम कुछ इसी तरह देखेंगे:

 > (defvar *journey* (make-instance 'journey :from "Christchurch" :to "Dunedin" :period 20 :mode "bicycle")) *JOURNEY* > (format nil "~a" *journey*) "#<JOURNEY {10044DCCA1}>" 

आप JOURNEY वर्ग के लिए PRINT-OBJECT विधि को परिभाषित कर सकते हैं, और इसका उपयोग किसी प्रकार की पाठ्य सामग्री के प्रतिनिधित्व को निर्धारित करने के लिए कर सकते हैं:

 (defmethod print-object ((j journey) (s stream)) (format s "~A to ~A (~A hours) by ~A." (from j) (to j) (period j) (mode j))) 

हमारी वस्तु अब नए पाठ दृश्य का उपयोग करेगी:

 > (format nil "~a" *journey*) "Christchurch to Dunedin (20 hours) by bicycle."