(कैसे लिखें (लिस्प) दुभाषिया)

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

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


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

लिस्फी सिंटैक्स और शब्दार्थ

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

जावा		योजना
if ( x.val() > 0 ) {<br> z = f(a * x.val() + b); <br>}		(if (> (val x) 0)<br> (set! z (f (+ (* a (val x)) b))))

ध्यान दें कि विस्मयादिबोधक चिह्न योजना में एक विशेष चरित्र नहीं है, यह " set! " नाम का सिर्फ एक हिस्सा है। केवल कोष्ठक विशेष वर्ण हैं। शुरुआत में एक विशेष कीवर्ड के साथ एक सूची जैसे (set! xy) को योजना में एक विशेष रूप कहा जाता है; भाषा की सुंदरता इस तथ्य में निहित है कि हमें केवल 6 विशेष रूपों की आवश्यकता है, साथ ही 3 सिंटैक्टिक निर्माण - चर, स्थिरांक और प्रक्रिया:

आकार	वाक्य-विन्यास	शब्दार्थ और उदाहरण
चर संदर्भ	वर	प्रतीक को चर के नाम के रूप में व्याख्या की जाती है; इसका मान चर का मूल्य है। उदाहरण: x
निरंतर शाब्दिक	संख्या	एक नंबर का मतलब खुद होता है। उदाहरण: 12 या -3.45e+6
उद्धरण	(quote विस्तार )	रिटर्न का मूल्यांकन किए बिना शाब्दिक रूप से समाप्त हो जाता है। उदाहरण: (quote (abc)) ⇒ (abc)
सशर्त	(if टेस्ट कॉन्सेप्ट ऑल )	परीक्षण की गणना करें; अगर सही है, तो गणना करें और वापसी करें ; अन्यथा गणना और कुल मिलाकर लौटें। उदाहरण: (if (< 10 20) (+ 1 1) (+ 3 3)) ⇒ 2
असाइनमेंट	(set! var ऍक्स्प )	कंप्यूटर पर वैरिएबल की गणना करें और असाइन करें, जिसे पहले परिभाषित किया जाना चाहिए ( define पैरामीटर के रूप में या प्रक्रिया पैरामीटर के रूप में)। उदाहरण: (set! x2 (* xx))
परिभाषा	(define var ऍक्स्प (define )	नेस्टेड वातावरण में ही एक नए चर को परिभाषित करें और इसे अभिव्यक्ति एक्सपी के मूल्यांकन का मूल्य दें। उदाहरण: (define r 3) या (define square (lambda (x) (* xx))) ।
समारोह	(lambda ( var ... ) exp )	नाम के साथ पैरामीटर (ओं) के साथ एक फ़ंक्शन बनाएं ... और शरीर में एक अभिव्यक्ति। उदाहरण: (lambda ( r ) (* 3.141592653 (* rr)))
अनुक्रम निर्धारण	(begin ऍक्स्प ... )	प्रत्येक अभिव्यक्ति को बाएं से दाएं की गणना करें और अंतिम मान लौटाएं। उदाहरण: (begin (set! x 1) (set! x (+ x 1)) (* x 2)) ⇒ 4
प्रक्रिया कॉल	( ऍक्स्प ... )	यदि खरीद नहीं if, set!, define, lambda, begin, या quote तब इसे एक प्रक्रिया के रूप में माना जाता है। इसकी गणना उन्हीं नियमों के अनुसार की जाती है जो यहां परिभाषित हैं। सभी अभिव्यक्तियों का मूल्यांकन किया जाता है, और फिर फ़ंक्शन को तर्क में अभिव्यक्तियों की सूची के साथ कहा जाता है। उदाहरण: (square 12) ⇒ 144

इस तालिका में, var को एक पहचानकर्ता वर्ण होना चाहिए, जैसे x या square ; संख्या - एक पूर्णांक या एक फ्लोटिंग-पॉइंट संख्या होनी चाहिए, जबकि इटैलिक में बाकी शब्द किसी भी अभिव्यक्ति हो सकते हैं। पदनाम ऍक्स्प ... का अर्थ है शून्य या अधिक एक्सप रिपिटिशन।

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

भाषा दुभाषिया क्या करता है

दुभाषिया में दो भाग होते हैं:

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

यह है कि व्याख्या प्रक्रिया और इंटरेक्टिव सत्र कैसा दिखता है, जिसमें दिखाया गया है कि लघु कार्यक्रम कैसे parse और eval प्रक्रिया है:

>> कार्यक्रम = "(शुरू आर 3 परिभाषित करें) (* 3.141592653 (* आर आर))"

>>> तोता ( कार्यक्रम )
[ ' शुरू ', [ ' परिभाषित ', 'आर', 3 ] , [ ' * ', 3.141592653 , [ ' * ', 'आर', 'आर' ] ]

>>> eval ( पार्स ( कार्यक्रम ) )
२८.२७,४३,३३,८७७

हम सबसे सरल आंतरिक प्रतिनिधित्व का उपयोग करते हैं, जहां सूचियाँ, संख्याएँ और योजना वर्ण क्रमशः पायथन सूचियों, संख्याओं और तारों द्वारा दर्शाए जाते हैं।

निष्पादन: eval

ऊपर दी गई तालिका में नौ मामलों में से प्रत्येक में कोड की एक, दो या तीन लाइनें हैं। eval को परिभाषित करने के लिए अधिक कुछ नहीं चाहिए:

def eval ( x, env = global_env ) :
"एक वातावरण में एक अभिव्यक्ति का मूल्यांकन करें।"
अगर isa ( x, Symbol ) : # चर संदर्भ
वापसी । खोजें ( x ) [ x ]
elif isa ( x, list ) नहीं : # निरंतर शाब्दिक
वापसी x
elif x [ 0 ] == 'उद्धरण' : # (उद्धरण ऍक्स्प)
( _, एक्सप ) = x
वापसी ऍक्स्प
एलिफ़ x [ 0 ] == 'अगर' : # (यदि टेस्ट कॉन्सेप्ट ऑल)
( _, परीक्षण , श्लोक, alt ) = एक्स
वापसी eval ( ( conseq if eval ( test , env ) alt ) , env )
elif x [ 0 ] == 'सेट!' : # (सेट! var ऍक्स्प)
( _, var, exp ) = x
env। ढूँढें ( var ) [ var ] = eval ( ऍक्स्प, env )
elif x [ 0 ] == 'परिभाषित' : # (var var exp exp) परिभाषित करें
( _, var, exp ) = x
env [ var ] = eval ( ऍप, env )
एलिफ़ x [ 0 ] == 'लैम्ब्डा' : # (लैम्ब्डा (var *) ऍक्स्प)
( _, vars , exp ) = x
वापसी lambda * आर्ग्स: eval ( ऍक्स्प, Env ( vars , args, env ) )
एलिफ़ x [ 0 ] == 'शुरू' : # (एक्सप्राइज़ * शुरू करें)
एक्स में विस्तार के लिए [ 1 : ] :
वैल = ईवैल ( ऍक्स्प, env )
वापसी घाटी
और : # (ऍक्स्प exp *)
एक्सपी = एक्स में एक्स के लिए [ eval ( exp, env ) ]
proc = exps। पॉप ( 0 )
वापसी खरीद ( * विस्तार )

isa = toinstance

प्रतीक = अकड़

आप सभी को यह जरूरी है कि पर्यावरण को छोड़कर ! पर्यावरण पात्रों से संबंधित मूल्यों का मानचित्रण मात्र है। define या ( lambda अभिव्यक्ति) का उपयोग करके नए चरित्र / मूल्य संबंध जोड़े जाते हैं।

आइए एक उदाहरण देखें कि क्या होता है जब हम योजना में एक फ़ंक्शन की घोषणा करते हैं और कॉल करते हैं (संकेत lis.py> इसका मतलब है कि हम लिस्प इंटरप्रेटर के साथ बातचीत कर रहे हैं, पायथन नहीं):

lis.py > ( डिफाइन एरिया ( लंबोदर ( r )) ( * 3.141592653 ( * r r ) ) )
lis.py > ( क्षेत्र 3 )
२८.२७,४३,३३,८७७

जब हम निष्पादित करते हैं (lambda ( r ) (* 3.141592653 (* rr))) , तो हम elif x[0] == 'lambda' में elif x[0] == 'lambda' शाखा को प्राप्त करते हैं (_, vars, exp) सूची x (_, vars, exp) संबंधित तत्वों (_, vars, exp) निर्दिष्ट करते हैं। और यदि लंबाई x 3 नहीं x तो एक त्रुटि का संकेत दें)। हम एक नया फ़ंक्शन बनाते हैं, जिसे कहा जाता है, अभिव्यक्ति का मूल्यांकन करता है ['*', 3.141592653 ['*', 'r', 'r']] जो फ़ंक्शन के औपचारिक मापदंडों के एक समूह द्वारा गठित वातावरण में (इस मामले में, केवल एक पैरामीटर r ) के साथ है। फ़ंक्शन कॉल में तर्क, साथ ही किसी भी चर के लिए वर्तमान वातावरण का उपयोग कर रहे हैं जो पैरामीटर नहीं हैं (उदाहरण के लिए, चर * )। इस नए बनाए गए फ़ंक्शन का मान global_env में area मान के रूप में असाइन किया गया area ।

अब, जब हम गणना करते हैं तो क्या होता है (area 3) ? क्योंकि क्षेत्र वर्णों का एक विशेष रूप नहीं है, इसका अर्थ है एक फ़ंक्शन कॉल (अंतिम else: अंतिम else: eval ), और अभिव्यक्तियों की पूरी सूची को एक बार में निष्पादित किया जाता है। area गणना उस फ़ंक्शन को वापस करती है जिसे हमने अभी बनाया है; गणना 3 रिटर्न 3 । तब ( eval की अंतिम पंक्ति के अनुसार), तर्क सूची [3] साथ नव निर्मित फ़ंक्शन [3] कहा जाता है। इसका अर्थ है exp , जो कि ['*', 3.141592653 ['*', 'r', 'r']] ऐसे वातावरण में जहाँ r 3 और बाहरी वातावरण वैश्विक है, और इसलिए * एक गुणन फ़ंक्शन है।

अब हम Env क्लास के विवरणों को समझाने के लिए तैयार हैं:

कक्षा एनव ( तानाशाही ) :
"एक पर्यावरण: एक बाहरी एनव के साथ {'var': val} जोड़े का एक ताना।"
def __init__ ( स्वयं , parms = ( ) , args = ( ) , बाहरी = कोई नहीं ) :
स्व । अद्यतन ( ज़िप ( अर्ध, आर्ग ) )
स्व । बाहरी = बाहरी
डीईएफ फाइंड ( सेल्फ , वर ) :
"अंतरतम खोजें, जहां var प्रकट होता है।"
स्व में वापसी अगर स्वयं में वर स्वयं । बाहरी । खोजें ( var )

ध्यान दें कि Env वर्ग एक उप- dict , जिसका अर्थ है कि सामान्य शब्दकोश संचालन उस पर काम करता है। इसके अलावा, दो तरीके हैं, कंस्ट्रक्टर __init__ और __init__ find चर के लिए सही वातावरण खोजने के लिए। इस वर्ग को समझने की कुंजी (साथ ही इस कारण से कि हम सिर्फ एक dict का उपयोग नहीं कर रहे हैं) बाहरी वातावरण की अवधारणा है। निम्नलिखित कार्यक्रम पर विचार करें:



प्रत्येक आयत एक पर्यावरण का प्रतिनिधित्व करता है, और इसका रंग इस वातावरण में परिभाषित चर के रंग से मेल खाता है। अंतिम दो पंक्तियों में, हम a1 और कॉल (a1 -20.00) को परिभाषित करते हैं; ये दो पंक्तियाँ $ 100 के शेष राशि और 20 डॉलर की बाद की निकासी के साथ एक बैंक खाते के निर्माण का प्रतिनिधित्व करती हैं। निष्पादन (a1 -20.00) दौरान (a1 -20.00) हम पीले रंग में प्रकाशित अभिव्यक्ति का मूल्यांकन करते हैं। इस अभिव्यक्ति में 3 चर शामिल हैं। amt चर को सबसे अधिक नेस्टेड (हरा) वातावरण में तुरंत पाया जा सकता है। लेकिन यहां balance परिभाषित नहीं किया गया है, हम बाहरी वातावरण में अपेक्षाकृत हरे रंग के लिए देखेंगे, अर्थात्। नीले रंग में। और अंत में, चर + इनमें से किसी भी वातावरण में नहीं मिला, हमें वैश्विक (लाल) वातावरण में एक और कदम उठाने की जरूरत है। बाहरी वातावरण से बाहरी की ओर बढ़ते हुए इस खोज प्रक्रिया को लेक्सिकल स्कूपिंग कहा जाता है। Procedure.find शाब्दिक दायरे के अनुसार सही वातावरण पाता है।

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

def add_globals ( env ) :
"एक पर्यावरण के लिए कुछ योजना मानक प्रक्रियाएं जोड़ें।"
आयात गणित , ऑपरेटर सेशन के रूप में
env। अद्यतन ( vars ( गणित ) ) # पाप, sqrt, ...
env। अद्यतन (
{ '+' : op। जोड़ें , '-' : op। उप , '*' : op। mul , '/' : op। div , 'नहीं' : op। नहीं_
'>' : op। gt , '<' : op। lt , '> =' : op। ge , '<=' : op। le , '=' : op। eq,
'बराबर?' : ऑप। eq , 'eq?' : ऑप। is_ , 'लंबाई' : len , 'cons' : lambda x, y: [ x ] + y,)
'कार' : लैम्ब्डा x: x [ 0 ] , 'cdr' : लैम्ब्डा x: x [ 1 : ] , 'एपेंड' : op। जोड़ें ,
'सूची' : लंबोदर * x: सूची ( x ) , 'सूची?' : लैम्ब्डा x: isa ( x, सूची ) ,
'अशक्त?' : लैम्ब्डा x: x == [ ] , 'प्रतीक?' : लैम्ब्डा x: isa ( x, प्रतीक ) } )
वापसी

global_env = add_globals ( Env ( ) )

पार्सिंग: read और parse

अब parse फ़ंक्शन के बारे में। विश्लेषण को पारंपरिक रूप से दो भागों में विभाजित किया गया है: लेक्सिकल विश्लेषण , जिसके दौरान वर्णों के इनपुट स्ट्रिंग को टोकन , और पार्सिंग के अनुक्रम में विभाजित किया जाता है, जिसके दौरान टोकन एक आंतरिक प्रतिनिधित्व में एकत्र किए जाते हैं। लिस्पी टोकन ब्रैकेट, वर्ण (जैसे set! या x ) और संख्याएँ हैं। यहां बताया गया है कि यह कैसे काम करता है:

>>> कार्यक्रम = "(सेट! x * 2 (* x 2))"

>>> टोकन ( कार्यक्रम )
[ ' ( ', ' सेट! ', 'x * 2 ', ' ( ', ' * ', 'x', ' 2 ', ' ) ', ' ) ' ]

>>> तोता ( कार्यक्रम )
[ ' सेट! ',' x * 2 ', [ ' * ',' x ', 2 ] ]

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

अब पार्सिंग के बारे में। हमने देखा कि लिस्प सिंटैक्स बहुत सरल है, लेकिन कुछ लिस्प व्याख्याकारों ने किसी भी अक्षर के स्ट्रिंग को स्वीकार करके और भी आसान बना दिया है जो एक कार्यक्रम के रूप में एक सूची है। दूसरे शब्दों में, स्ट्रिंग (set! 1 2) को सिंटैक्टिकली सही प्रोग्राम द्वारा स्वीकार किया जाएगा, और केवल रन के समय ही इंटरप्रेटर उस set! कसम खाएगा set! पहले तर्क के रूप में एक चरित्र की अपेक्षा, संख्या नहीं। जावा या पायथन में, 1 = 2 समतुल्य असाइनमेंट को संकलन-समय त्रुटि के रूप में मान्यता दी जाएगी। दूसरी ओर, जावा और पायथन को x/0 अभिव्यक्ति में त्रुटियों के संकलन के दौरान पता लगाने की आवश्यकता नहीं होती है, इसलिए, जैसा कि आप देख सकते हैं, यह हमेशा सख्ती से परिभाषित नहीं होता है जब त्रुटियों को पहचाना जाना चाहिए। लिस्फी ने read का उपयोग करते हुए parse , एक ऐसा फ़ंक्शन जो किसी भी अभिव्यक्ति (संख्या, वर्ण या नेस्टेड सूची) को पढ़ता है।

read फ़ंक्शन लेक्सिकल विश्लेषण के बाद प्राप्त read_from टोकन को पास करके काम करता है। टोकन की सूची होने के बाद, हम पहले टोकन को देखते हैं; अगर यह ')' एक वाक्यविन्यास त्रुटि है। यदि यह '(' , तो हम तब तक अभिव्यक्तियों की एक सूची बनाना शुरू करते हैं, जब तक कि हम संबंधित ')' तक नहीं पहुंच जाते। ')' बाकी सब कुछ चरित्र या संख्या होना चाहिए, जो स्वयं में पूर्ण अभिव्यक्ति हैं। अंतिम चाल यह जानना है कि '2' एक पूर्णांक का प्रतिनिधित्व करता है, '2.0' एक फ्लोटिंग-पॉइंट नंबर है, और x एक चरित्र का प्रतिनिधित्व करता है। हम पायथन को इन अंतरों को बनाने की अनुमति देंगे: प्रत्येक गैर-ब्रैकेटेड टोकन के लिए, पहले इसे एक पूर्णांक के रूप में व्याख्या करने की कोशिश करें, और फिर एक फ्लोटिंग-पॉइंट संख्या के रूप में, और अंत में एक चरित्र के रूप में। इन निर्देशों का पालन हमें मिलता है:

डीईएफ़ रीड ( s ) :
"एक स्ट्रिंग से एक योजना अभिव्यक्ति पढ़ें।"
वापसी पढ़ें_फ्रेम ( टोकन )

parse = पढ़ा

tokenize ( s )
"एक स्ट्रिंग को टोकन की सूची में बदलें।"
वापस लौटें । ( '(' , ' ' '' '' '' '' '' '' ) को प्रतिस्थापित करें । विभाजन ( )

def read_from ( टोकन ) :
"टोकन के अनुक्रम से एक अभिव्यक्ति पढ़ें।"
अगर लेन ( टोकन ) == 0 :
SyntaxError बढ़ाएँ ( 'पढ़ते समय अप्रत्याशित EOF' )
टोकन = टोकन। पॉप ( 0 )
यदि '(' == टोकन) :
एल = [ ]
टोकन के समय [को ० ] ! = ')' :
एल। जोड़ें ( read_from ( टोकन ) )
टोकन। pop ( 0 ) # pop off ')' '
वापसी L
एलिफ ')' == टोकन :
SyntaxError ( 'अप्रत्याशित)' बढ़ाएँ
और :
वापसी परमाणु ( टोकन )

डीओटी एटम ( टोकन ) :
"संख्याएँ संख्याएँ बन जाती हैं; हर दूसरा टोकन एक प्रतीक है।"
कोशिश : वापसी int ( टोकन )
मान को छोड़कर :
कोशिश : रिटर्न फ्लोट ( टोकन )
मान को छोड़कर :
वापसी प्रतीक ( टोकन )

अंत में, हम अभिव्यक्ति को एक पठनीय लिस्प स्ट्रिंग में बदलने के लिए, साथ ही to_string फ़ंक्शन को जोड़ने के लिए to_string फ़ंक्शन to_string , जो कि इंटरएक्टिव इंटरप्रेटर के रूप में रीड-इवल-प्रिंट चक्र के लिए आवश्यक है:

to_string ( exp ) :
"पाइथन ऑब्जेक्ट को एक लिस्प-पठनीय स्ट्रिंग में बदलें।"
वापसी '(' + '' । ज्वाइन ( नक्शा ( to_string, exp ) ) + ')' ' अगर is ( ऍक्स्प, सूची ) और अधिक str ( exp )

def उत्तर ( शीघ्र = 'lis.py>' ) :
"प्रांप्ट-रीड-एवल-प्रिंट लूप।"
जबकि सच :
वैल = एवल ( पार्स ( रॉ_इनपुट ( प्रॉम्प्ट ) ) )
अगर वैल कोई नहीं है : प्रिंट to_string ( वैल )

यहाँ काम में हमारा कोड है:

>>> उत्तर ( )
lis.py > ( डिफाइन एरिया ( लंबोदर ( r )) ( * 3.141592653 ( * r r ) ) )
lis.py > ( क्षेत्र 3 )
२८.२७,४३,३३,८७७
lis.py > ( डिफ़ाइंड फैक्ट ( लंबोदर ( n ) ( यदि ( <= n 1 ) 1 ( * n ( तथ्य ( - n 1 ) ) ) ) )
lis.py > ( तथ्य 10 )
3628800
lis.py > ( तथ्य 100 )
9332621544394415268169923885626670049071596826438162146859296389521759999322991
5608941463976156518286253697920827223758251185210916864000000000000000000000000
lis.py > ( क्षेत्र ( तथ्य 10 ) )
4.1369087198e + 13
lis.py > ( पहली कार परिभाषित करें )
lis.py > ( डिफाइन रेस्ट सीडीआर )
lis.py > ( डिफाइन काउंट ( लंबो ( आइटम L )) ( यदि L ( + ( बराबर ; आइटम ( पहला L ) )) ( काउंट आइटम ( बाकी L ) ) ) 0 ) )
lis.py > ( गणना 0 ( सूची 0 1 2 3 0 0 ) )
3
lis.py > ( गिनें ) ( उद्धरण ) ( भाव जितना बड़ा होगा उतना अच्छा ) )
4

लिस्पी कितना छोटा / तेज / पूर्ण / अच्छा है?

हम लिसपी को निम्न मानदंडों से परखेंगे:

• आकार: लिस्फी छोटे, टिप्पणी के बिना 90 लाइनें, 4K स्रोत कोड से कम। पहले संस्करण की तुलना में कम लाइनें हैं, जिसमें 96 लाइनें थीं - मैंने Procedure वर्ग की परिभाषा को हटाने और इसके बजाय पायथन lambda उपयोग करने के लिए एरिक कूपर के सुझाव को स्वीकार किया। मेरी योजना का सबसे छोटा जावा संस्करण ( Jscheme ) 1664 लाइनों और 57K स्रोत कोड से मिलकर बना था। Jsceheme को मूल रूप से SILK (स्कीम इन फिफ्टी किलोबाइट्स, स्कीम इन 50 किलोबाइट्स) कहा जाता था, लेकिन मैं इस सीमा को केवल परिणामी बायोटेक के संबंध में मिला। मुझे लगता है कि यह 1972 एलन Kay आवश्यकता को संतुष्ट करता है जिसे आप "कोड पेज" में "दुनिया की सबसे शक्तिशाली भाषा" कह सकते हैं ।
  

  bash $ grep "^ \ s * [^ # \ s]" lis.py | WC
  90 398 3423

  
  
• गति: 0.004 सेकंड में लिस्पी गणना (fact 100) । मेरे लिए, यह तेजी से पर्याप्त है (हालांकि इसे गिनने के अन्य तरीकों की तुलना में बहुत धीमा है)।
  
• पूर्णता: लिस्फी योजना मानक का पूरी तरह से पालन नहीं करता है। यहाँ मुख्य नुकसान हैं:
  
  • सिंटैक्स: लापता टिप्पणियां, उद्धृत / अर्ध-उद्धरण, # शाब्दिक, व्युत्पन्न अभिव्यक्ति प्रकार (जैसे कि cond , if से व्युत्पन्न, या let , लंबो से व्युत्पन्न), और बिंदीदार सूची संकेतन।
    
  • शब्दार्थ: लापता कॉल / सीसी और पूंछ पुनरावृत्ति।
    
  • डेटा प्रकार: कोई लाइनें, एकल वर्ण, बूलियन प्रकार, पोर्ट, वैक्टर, सटीक / गलत संख्या। पायथन में सूचियाँ वास्तव में जोड़े और सूचियों की तुलना में योजना में वैक्टर के करीब हैं।
    
  • कार्य: 100 से अधिक आदिम कार्य नहीं हैं, जिनमें से अधिकांश गायब डेटा प्रकारों के लिए डिज़ाइन किए गए हैं, साथ ही कुछ अन्य (जैसे set-car! और set-cdr! हम set-cdr! लागू नहीं कर सकते हैं set-cdr! पूरी तरह से पायथन सूचियों का उपयोग करके) ।
    
  • त्रुटि से निपटने: लिस्फी त्रुटियों का पता लगाने, उनमें से एक स्वीकार्य रिपोर्ट बनाने या पुनर्प्राप्त करने का प्रयास नहीं करता है। Lispy प्रोग्रामर उत्कृष्टता की उम्मीद करता है।
    
  
  
• अच्छा: यह पाठकों पर निर्भर है। मुझे लिस्प के व्याख्याकारों को समझाने के उद्देश्य से यह अच्छा लगता है।
  

सच्ची कहानी

इस विचार पर लौटना कि व्याख्याकार कैसे काम करते हैं, यह जानना बहुत उपयोगी हो सकता है, मैं एक कहानी बताऊंगा। 1984 में, मैंने डॉक्टरेट शोध प्रबंध लिखा। यह LaTeX से पहले था, माइक्रोसॉफ्ट वर्ड से पहले - हमने ट्रॉफ का इस्तेमाल किया। दुर्भाग्य से, ट्रॉफ के पास प्रतीकात्मक लेबलों को संदर्भित करने का कोई तरीका नहीं था: मैं लिखना चाहता था "जैसा कि हम @theoremx पृष्ठ पर देखेंगे" और फिर उपयुक्त स्थान में "@ (सेट प्रमेक्स \ n%)" जैसा कुछ लिखें ( ट्रॉफ़ आरक्षित \ n% पृष्ठ संख्या के रूप में)। मेरे दोस्त टोनी डेरोस को भी ऐसी ही जरूरत महसूस हुई, और साथ में हमने एक साधारण लिस्प प्रोग्राम को स्केच किया जो प्रीप्रोसेसर के रूप में काम करता था। हालांकि, यह पता चला कि उस समय हमारे पास जो लिस्प था वह लिस्प के भावों को पढ़ने के लिए अच्छा था, लेकिन बाकी सब पढ़ने के लिए इतना धीमा था कि यह कष्टप्रद था।

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

अंत में, हम दोनों ने एक परिणाम हासिल किया।

सभी एक साथ

पूर्ण लिस्फ़ी कोड डाउनलोड के लिए उपलब्ध है: lis.py