आमतौर पर लैम्ब्डा कैलकुलस, कॉम्बिनेटर, अनलांबडा और फाइबोनैचि संख्या

निम्नलिखित, मेरी राय में, कट्टर प्रोग्रामिंग पद्धति के बारे में एक कहानी है।
पोस्ट का विषय आसान नहीं है, रास्ता लंबा होगा, और अंत में एक कुकी के रूप में मैं आपको बताऊंगा कि अनलांबा में फाइबोनैचि संख्याओं की गणना कैसे करें।

पारखी लोगों के लिए: लेख यह समझाने की अधिक संभावना है कि यह कैसे काम करता है, बजाय एक सख्त औपचारिक विवरण के।

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

ठेठ λ-पथरी

मान लीजिए कि हमारे पास एक ही तर्क के कार्य हैं। इसके अलावा, उनके तर्क और वापसी मूल्य दोनों भी एक तर्क के कार्य हैं।

यहां गणितज्ञों को आपत्ति होगी: हमें एक ऐसा सेट मिलता है जो स्वयं से स्वयं के कार्यों के सेट से मेल खाता है, जो सेट थ्योरी में नहीं हो सकता है (यहां तक ​​कि अनंत सेट के मामले में, फ़ंक्शन का सेट सख्ती से अधिक है)। लेकिन यह अमेरिकी स्कॉट को आंशिक रूप से ऑर्डर किए गए सेटों पर एक विशेष टोपोलॉजी पेश करके कार्टेसियन-बंद श्रेणी के निर्माण से नहीं रोकता था, अर्थात्। प्रस्तुत वस्तु मौजूद नहीं है, लेकिन यह एक पूरी तरह से अलग कहानी है।

तो, ऐसा लगता है कि हम हाथ में अजीब कार्यों के केवल ऐसे सार और असीम सेट के साथ क्या कर सकते हैं? शुरू करने के लिए, यह तय करना अच्छा होगा कि इन कार्यों को कैसे लिखना है। Λ-पथरी में, निम्नलिखित नियम अपनाए जाते हैं:

• च और कुछ कार्य होने दो। तब पिता फ़ंक्शन a , या, λ-पथरी की शब्दावली में, एक अनुप्रयोग के लिए फ़ंक्शन के अनुप्रयोग को दर्शाता है।
• F को एक ऐसा एक्सप्रेशन दें जिसमें स्वतंत्र रूप से वेरिएबल x हो या जिसमें यह बिल्कुल न हो। तब λx.F वेरिएबल x के एक फंक्शन को दर्शाता है जिसका मान F द्वारा दिया गया है, और इसे λ- abractionraction कहा जाता है ।

तब λx.fx = f , क्योंकि यह फ़ंक्शन तर्क x लेता है और मान fx देता है , जो फ़ंक्शन f स्वयं करता है। इसे is परिवर्तन कहा जाता है।

उदाहरण के लिए, λx.x ² स्क्वेरिंग फ़ंक्शन है, और (λx.x ² ) 3 इस फ़ंक्शन का तर्क 3 करने के लिए है। अंतर्ज्ञान से पता चलता है कि इस अभिव्यक्ति का मूल्य 9 है, जो λ- कैलकुलस का एकमात्र स्वयंसिद्ध है, जिसे x- कहा जाता है। कमी :

• (λx.F) a = F [x: = a]

जहाँ F [x: = a] का अर्थ है अभिव्यक्ति F, जिसमें x के लिए एक प्रतिस्थापित किया जाता है। इस स्वयंसिद्ध के साथ, λ-पथरी एक ट्यूरिंग-पूर्ण प्रोग्रामिंग भाषा बन जाती है, अर्थात किसी भी एल्गोरिथ्म को उस पर लागू किया जा सकता है (एक एल्गोरिथ्म का एक उचित अर्थ में)। एक स्वाभाविक प्रश्न उठता है - कैसे?

पहचान फ़ंक्शन को स्केच करना आसान है जो बस अपना तर्क देता है: λx.x
निरंतर फ़ंक्शन भी जटिलताओं का कारण नहीं बनता है: λx.c , जहां सी x से स्वतंत्र है। वास्तव में, किसी भी तर्क के लिए, फ़ंक्शन सी वापस आ जाएगा।
वह सब मालूम होगा। हम यह भी नहीं जानते कि कई तर्कों के कार्यों का निर्माण कैसे करें! नहीं, हम कर सकते हैं, हम अभी इसके बारे में नहीं जानते हैं।

निम्नलिखित उदाहरण पर विचार करें: λx.λy.x + y । अधिक स्पष्टता के लिए, हम कोष्ठक डालते हैं: λx। (.y। (X + y)) एक ऐसा फ़ंक्शन है जो एक और फ़ंक्शन देता है जो योग देता है। यह कैसे काम करता है? आइए इसे कुछ तर्क पर लागू करें: (λx। (.Y। (X + y))) a = λy। (A + y) । परिणामी फ़ंक्शन दूसरे तर्क पर लागू होता है: (λy। (A + y)) b = a + b । इस तकनीक को करी , या करी (हास्केल करी के बाद) कहा जाता है, और किसी भी तर्क के लिए काम करता है। हम इस बात से सहमत हैं कि यदि फ़ंक्शन में λx है। (.y। (.Z। (F))) , तो हम इसे λxyz.F के रूप में लिखेंगे। हम यह भी मानते हैं कि (फेबक) का अर्थ है
(((fa) b) c) अब कई तर्कों के कार्य बहुत सरलता से लिखे गए हैं: λxy.x + y , और उनका अनुप्रयोग है (फैब) ।

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

नियंत्रण संरचनाओं

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

निम्नलिखित कार्य पर विचार करें: w = λx.xx. वह अपने तर्क को खुद पर लागू करती है (याद रखें, हमारे लिए, आप जो भी लेते हैं वह एक फ़ंक्शन है)। आइए इस फ़ंक्शन को स्वयं पर लागू करने का प्रयास करें: ww = (λx.xx) w = (xx) [x: = w] = ww । उफ़, ops-कटौती का उपयोग करते हुए, हम वहां आए जहां हमने शुरुआत की थी। यह λ-पथरी में एक अनंत लूप के सबसे सरल उदाहरणों में से एक है, यह उल्लेखनीय है कि यह बिल्कुल कुछ भी नहीं करता है।

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

• true = λxy.x
• झूठी = λxy.y

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

अब चलो छोरों और पुनरावृत्ति की शास्त्रीय समस्या को हल करने की कोशिश करते हैं - तथ्य की गणना। आइए हम पहले से ही संख्याएँ, अंकगणितीय संक्रियाएँ (जो अब हम λ-कलन की शैली में उपसर्ग संकेतन में लिखेंगे), एक डिक्शन फ़ंक्शन जो इसके तर्क को 1 से कम कर देता है, और एक शून्य फ़ंक्शन भी जिसके साथ हम संख्या को शून्य पर समानता की जाँच कर सकते हैं ।
g = λrn। (शून्य n) 1 (* n (rr (dec n)))
आइए ध्यान से देखें: फ़ंक्शन शून्य के लिए समानता के लिए n की जांच करता है, 1 सफल होने पर रिटर्न देता है, अन्यथा रिटर्न (* n (rr (dec n))) - n का उत्पाद और स्वयं और n-1 से फ़ंक्शन r का मान। फ़ंक्शन आर क्या है? यह पुनरावृत्ति करने के लिए एक तरह की हैक है - आर के रूप में हम फ़ंक्शन जी को स्वयं पास करेंगे, जिसका अर्थ है कि लिखित अभिव्यक्ति वास्तव में भाज्य की गणना करती है: जी (एन) = एन * जी (एन -1) । चूंकि प्रत्येक बार स्वयं कार्य करने के लिए असुविधाजनक है, इसलिए हम इस तथ्य का अंतिम कार्यान्वयन करेंगे:
च = जीजी
इस प्रकार, जी अपने पहले तर्क को "याद" करेगा , और जो कुछ भी है वह गणना के लिए वांछित संख्या को पारित करना है।

आगे और भी बुरा।

फिक्स्ड प्वाइंट कॉम्बिनेटर

यह पता चला है कि किसी भी फ़ंक्शन के लिए लैम्ब्डा कैलकुलस में एक तर्क x मौजूद है जैसे कि fx = x । इसके अलावा, इस एक्स हमेशा पाया जा सकता है! यह काम तथाकथित फिक्स्ड पॉइंट कॉम्बिनेटर द्वारा किया जाता है । इसके विकल्पों में से एक, हमारे प्यारे हास्केल करी द्वारा आविष्कार किया गया:
Y = λf। (Λx.f (xx)) (λx.f (xx))
आइए देखें कि यह कैसे काम करता है:
Y f = (λx.f (xx)) (λx.f (xx)) = f ((λx.f (xx))) (λx.f (xx)) = f (Y f)
इस प्रकार, वाई एफ वास्तव में फ़ंक्शन एफ का एक निश्चित बिंदु है, क्योंकि एफ (वाई एफ) = वाई एफ ।

संख्या और अंकगणित

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

हम एक गैर-नकारात्मक संख्या N को एक फ़ंक्शन के रूप में परिभाषित करते हैं जो कुछ फ़ंक्शन f , तर्क x और N बार x से f के मान की गणना करता है:

• 0: x
• 1: f (x)
• 2: f (f (x))
• 3: f (f (f (x)))

इस प्रकार, λ-पथरी में, हमारी संख्या इस तरह दिखती है:

• 0: λfx.x
• 1: λfx.fx
• 2: λfx.f (fx)
• 3: λfx.f (f (fx))

समारोह:
inc = λnfx.f (nfx)
हमने फ़ंक्शन को n बार लागू किया, और इसे n + 1 प्राप्त करने के लिए एक बार फिर से लागू किया।

M और n को कैसे जोड़े? आपको पहले x और फिर n बार x से f लगाने की आवश्यकता है:

जोड़ें = λmnfx.mf (nfx)

गुणन को आसान बनाया गया है, आपको x m बार लागू करने की आवश्यकता है:

बहु = λmnf.m (nf)

एक शक्ति को उठाना - और भी आसान:
पाउ = λmn.nm

हम एक फ़ंक्शन लिखेंगे जो यह जांचता है कि क्या हमारा तर्क शून्य है:
λn.n (λx.false) सच है
यदि तर्क शून्य है, तो यह (जैसा कि आप परिभाषा से याद करते हैं) बस दूसरा तर्क लौटाएगा, अर्थात। सच है , अन्यथा यह कई बार होगा (ठीक है, कम से कम एक बार) समारोह λx.false को वहां कुछ करने के लिए लागू करें। इसलिए हमने जिन स्थिरांक के बारे में बात की, वे काम में आए - वापसी मूल्य गलत होगा।

अब कुछ कठिन घटाव है। सबसे पहले, हम एक फ़ंक्शन बनाते हैं जो एक नंबर 1 कम (या कुछ और अगर तर्क 0 है) लौटाता है। यहाँ यह है:
dec = λnfx.n (λgh.h (gf)) (λu.x) (λu.u)
मुझे लगता है कि अब भी सबसे लगातार लोग इस सवाल के संबंध में अपनी तंत्रिका खो देते हैं कि "यह काम कैसे होता है?" आइए समझने की कोशिश करते हैं।

सबसे पहले, आइए एक टुकड़ा n (λgh.h (gf)) (λu.x) देखें - कुछ अज्ञात n (λu.x) n बार लागू किया जाता है। चलो चर्च की संख्या की तरह है और लागू होते हैं:

• पहली बार: (λgh.h (gf)) (λu.x) = λh.h ((λu.x) f) = λh.hx = λh.h (0 fx) (शून्य की परिभाषा द्वारा)
• दूसरी बार: (λgh.h (gf)) (λh.hx) = λh.h ((λh.hx) f) = λh.h (fx) = λh.h (1 fx) (यहां यह समझना होगा कि h अंदर कोष्ठक और एच बाहरी - विभिन्न चर)
• तीसरी बार: (λgh.h (gf)) (λh.h (fx)) = λh.h ((λh.h (fx)) f) = λh.h (f (fx)) = λh.h (2) fx)

इसलिए, हम देखते हैं कि n अनुप्रयोगों के बाद, हमारी अभिव्यक्ति का रूप है:
dec n = λfx। (λh.h ((n-1) fx)) ((λu.u)) = λfx। (λu.u) ((n-1) fx) = theλfx (n-1) fx। = (एन -1)
लाभ!
लेकिन शून्य के मामले में फ़ंक्शन क्या लौटेगा?
dec 0 = λfx। (λu.x) (λu.u) = λfx.x = 0

मैं ध्यान देता हूं कि हमारी परिभाषाओं में ० और असत्य समान हैं।

अब यह लिखना और घटाना आसान है:
sub = λmn। (n dec) m

combinators

संयोजक λ- फ़ंक्शंस होते हैं जिनमें मुक्त चर नहीं होते हैं, अर्थात उनमें से कोई भी चर एक λ-abstraction द्वारा जुड़ा हुआ है।
गैर- कॉम्बिनेटर के उदाहरण:

• λx.y
• λxyz.y (zt)

कॉम्बिनेटर के उदाहरण:

• I = λx.x - फ़ंक्शन अपने तर्क को वापस करता है
• के = λxy.x - निरंतर जनरेटर
• S = λxyz। (Xz) (yz)
• Y = λf। (Λx.f (xx)) (λx.f (xx)) - अब आप जानते हैं कि इसे कॉम्बिनेटर क्यों कहा जाता है
• बी = λxyz.x (yz)
• सी = λxyz.xzy
• डब्ल्यू = λxy.xyy

और एक और दिलचस्प तथ्य: कॉम्बिनेटरों का एक परिमित सेट चुनना संभव है जिसके माध्यम से किसी भी अन्य λ-फ़ंक्शन को व्यक्त किया जा सकता है! इस तरह के किट हैं, उदाहरण के लिए, SKI और BCKW ।

Unlambda

अनलैम्ब्डा एक शुद्ध कार्यात्मक प्रोग्रामिंग भाषा है जिसमें कॉम्बिनेटरियल लॉजिक का उपयोग किया जाता है। अर्थात्, फ़ंक्शंस बनाने के लिए, यह SKI सेट का उपयोग करता है। फ़ंक्शन F को फ़ंक्शन G पर लागू करने को `FG के रूप में लिखा जाता है, जो हमें अनावश्यक कोष्ठक से बचाता है। एक पंक्ति में कई तर्क लागू करना: `fxyz । अंतर्निहित कार्यों के अलावा , के, i , भाषा में स्क्रीन पर प्रदर्शित करने की क्षमता है ( .x मैं के समान फ़ंक्शन को दर्शाता है, लेकिन जैसा कि साइड इफेक्ट स्क्रीन पर वर्ण x प्रदर्शित करता है), साथ ही इनपुट और लंबित गणना के लिए तंत्र, लेकिन हम उनके बारे में बात कर रहे हैं। नहीं जाएगा।

एक बार, एक दूर की, दूर की आकाशगंगा में, मुझे कुछ अनलम्बे ट्यूटोरियल मिले जो कुछ इस तरह से समाप्त हुए:

अब मैं यह समझाना चाहता था कि इस भाषा में कैसे एक चक्र लिखना संभव है जो फाइबोनैचि संख्याओं की गणना करता है, लेकिन यहां पहले से ही मैं शक्तिशाली हूं:
`` `s``````की
`k। *` `s``s `ks
`` s`k``ks``s`````````````````
`k``s`ksk

अच्छा, चलो कोशिश करते हैं।
वैसे, प्रोग्राम स्क्रीन पर तारों की संगत संख्या के रूप में फाइबोनैचि संख्या प्रदर्शित करता है।

हम चक्र का वर्णन करते हैं:

1. एन स्टार्स प्रदर्शित करें
2. हम अनुवाद को एक नई लाइन पर प्रिंट करते हैं (ublambda में, r फ़ंक्शन ऐसा करता है)
3. याद किए गए पिछले फाइबोनैचि संख्या में एन जोड़ें

अभी के लिए, हम λ-पथरी से परिचित (पहले से) की शैली में सब कुछ लिखेंगे।

एन स्टार प्रिंट करें: एन प्रिंट आई - एन बार हम समान फ़ंक्शन पर प्रिंट लागू करते हैं, उसी समय एन सितारों को प्रिंट करते हैं। नतीजतन, हमें एक समान कार्य मिलता है। आइए इसे कुछ पर लागू करें! ((एन प्रिंट आई) न्यूलाइन) (चक्र (+ एनएम) एन) , जहां एम पिछले फाइबोनैचि संख्या है। इसलिए, हमें चक्र के एक पास का ऐसा कार्य मिला:
चक्र = λcnm। ((n प्रिंट i) न्यूलाइन) (c (+ nm) n)
हम खुद को एक पैरामीटर के रूप में पाश में पास करते हैं, और इसे एक और शून्य के साथ आरंभ करते हैं:
तंतु = चक्र चक्र १ ०

जैसा कि मैंने वादा किया था, इसे अनलम्बा में अनुवाद करने के लिए शेष है। ओह।

पाठक को λ-पथरी से SKI सेट में अभिव्यक्ति का अनुवाद करने के लिए एल्गोरिदम से परिचित कराना अच्छा होगा (जो, संयोग से, दिखाता है कि किसी भी फ़ंक्शन को SKI के माध्यम से व्यक्त किया जा सकता है)। तो, एल्गोरिथ्म ही:

• λx.F , जहां F , x से स्वतंत्र है - हमें F के मान के साथ एक स्थिर फ़ंक्शन की आवश्यकता है, जिसका अर्थ है कि यह KF है
• λx.x परिभाषा के अनुसार मैं हूं
• λx.FG , जहां एफ और जी अभिव्यक्ति हैं (संभवतः) स्वतंत्र रूप से एक्स युक्त। हमें दोनों भावों में x मान को प्रतिस्थापित करना होगा, और फिर पहले से दूसरे तक को लागू करना होगा। यह वही है जो एस : एसएफजी कॉम्बिनेटर करता है।

अंतिम को छोड़कर, सब कुछ कमोबेश स्पष्ट है। आइए कॉम्बिनेटरियल S की परिभाषा को देखें:
S = λxyz। (Xz) (yz)
इसे F , G पर लागू करें:
SFG = (λyz। (F z) (yz)) G = λz। (F z) (G z)
वास्तव में, यह वही है जो हमें चाहिए।

अनुवाद एल्गोरिथ्म λx.F निम्न क्रियाओं के लिए आता है:

• `` के साथ बदलें
• x मैं के साथ बदलें
• X का x स्वतंत्र, `kG से बदलें

अब हम "ईंटों" का अनुवाद करेंगे जिसकी हमें आवश्यकता है:
0 = `की
1 = आई
जोड़ें:

`` s``s`ks`````````````````` `s`ks``s`kk`kk``s`kk`k
s``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s `` s`ks```kk`k```kk`
ks``s``s`ks``s`kk`kk``s`kk`ki``s``s`ks``s``s`ks``s`kk`ks``s` `s`ks``s`kk`kk``s`kk
`kk``s``s`ks``s`kk`kk`ki``s``s`ks``s``s`ks``s`kk`ks``s``s`ks `` s```ks```kk`ks``
s``s`ks``s`kk`kk``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s``s` ks``s``s`ks``s`kk`ks`
`s``s`ks``s`kk`kk``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s``s `ks``s`kk`kk``s`kk`kk
`` s`kk`ki`````s`````````````````````````k````k `kk``s``s`ks``s`kk`k
k`ki``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s`kk`kk`` s``s`ks``s`kk`kk``s`
KKI

चक्र:

`` s``s`ks`````````````````` `s`ks``s`kk`kk``s`kk`k
s``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s `` s`ks```kk`k```kk`
ks``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s `` s`ks```kk`kk``s `kk
`ks``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks`` s``s`ks``s`kk`kk``s`k
k`ks``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s`kk`kk`` s``s`ks``s`kk`kk`ki`
`s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s`kk`kk``s``s `ks``s`kk`kk``s`kk`k। *
`` s``s`ks`````````````````` s`ks``s`kk`kk``s`kk`k
i``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s`kk`kk``s` `s`ks``s`kk`kk``s`kk`
kr``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s `` s`ks```kk`kk``s `kk
`ks``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks`` s``s`ks``s`kk`kk``s`k
k`ks``s``s`ks``s`kk`kk``s`kk`ki``s``s`ks``s``s`ks``s`kk`ks`` s``s`ks``s``s`ks``s`
kk`ks``s``s`ks``s`kk`kk``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks`` s``s`ks``s``s`ks``s
`kk`ks``s``s`ks``s`kk`kk``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks` `s``s`ks``s`kk`kk``
s`kk`kk``s`kk`ki``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk `` s`kk`kk``s ``ks`
`s`kk`kk`ki``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s` kk`kk``s``s`ks``s`kk
`kk``s`kki``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s`kk `kk``s``s`ks``s`kk`
kk`ki

और समाप्त कार्यक्रम:

`` ``
`` s``s`ks`````````````````` `s`ks``s`kk`kk``s`kk`k
s``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s `` s`ks```kk`k```kk`
ks``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s `` s`ks```kk`kk``s `kk
`ks``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks`` s``s`ks``s`kk`kk``s`k
k`ks``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s`kk`kk`` s``s`ks``s`kk`kk`ki`
`s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s`kk`kk``s``s `ks``s`kk`kk``s`kk`k। *
`` s``s`ks`````````````````` s`ks``s`kk`kk``s`kk`k
i``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s`kk`kk``s` `s`ks``s`kk`kk``s`kk`
kr``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s `` s`ks```kk`kk``s `kk
`ks``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks`` s``s`ks``s`kk`kk``s`k
k`ks``s``s`ks``s`kk`kk``s`kk`ki``s``s`ks``s``s`ks``s`kk`ks`` s``s`ks``s``s`ks``s`
kk`ks``s``s`ks``s`kk`kk``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks`` s``s`ks``s``s`ks``s
`kk`ks``s``s`ks``s`kk`kk``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks` `s``s`ks``s`kk`kk``
s`kk`kk``s`kk`ki``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk `` s`kk`kk``s ``ks`
`s`kk`kk`ki``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s` kk`kk``s``s`ks``s`kk
`kk``s`kki``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s`kk `kk``s``s`ks``s`kk`kk`ki
`` s``s`ks`````````````````` `s`ks``s`kk`kk``s`kk`k
s``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s `` s`ks```kk`k```kk`
ks``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s `` s`ks```kk`kk``s `kk
`ks``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks`` s``s`ks``s`kk`kk``s`k
k`ks``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s`kk`kk`` s``s`ks``s`kk`kk`ki`
`s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s`kk`kk``s``s `ks``s`kk`kk``s`kk`k। *
`` s``s`ks`````````````````` s`ks``s`kk`kk``s`kk`k
i``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s`kk`kk``s` `s`ks``s`kk`kk``s`kk`
kr``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s `` s`ks```kk`kk``s `kk
`ks``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks`` s``s`ks``s`kk`kk``s`k
k`ks``s``s`ks``s`kk`kk``s`kk`ki``s``s`ks``s``s`ks``s`kk`ks`` s``s`ks``s``s`ks``s`
kk`ks``s``s`ks``s`kk`kk``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks`` s``s`ks``s``s`ks``s
`kk`ks``s``s`ks``s`kk`kk``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks` `s``s`ks``s`kk`kk``
s`kk`kk``s`kk`ki``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk `` s`kk`kk``s ``ks`
`s`kk`kk`ki``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s` kk`kk``s``s`ks``s`kk
`kk``s`kki``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s`kk `kk``s``s`ks``s`kk`kk`ki
`` s``s`ks`````````````````` `s`ks``s`kk`kk``s`kk`k
s``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s `` s`ks```kk`k```kk`
ks``s``s`ks``s`kk`kk``s`kk`ki``s``s`ks``s``s`ks``s`kk`ks``s` `s`ks``s`kk`kk``s`kk
`kk``s``s`ks``s`kk`kk`ki``s``s`ks``s``s`ks``s`kk`ks``s``s`ks `` s```ks```kk`ks``
s``s`ks``s`kk`kk``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s``s` ks``s``s`ks``s`kk`ks`
`s``s`ks``s`kk`kk``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s``s `ks``s`kk`kk``s`kk`kk
`` s`kk`ki`````s`````````````````````````k````k `kk``s``s`ks``s`kk`k
k`ki``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s`kk`kk`` s``s`ks``s`kk`kk``s`kki
i`ki

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