दिमाग को फोर्थ से मैश करें?

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



मैं फोर्थ में प्रोग्रामिंग को उबंटू ऑपरेटिंग सिस्टम के हिस्से के रूप में मानूंगा। अन्य ऑपरेटिंग सिस्टम के लिए कंपाइलरों की एक सूची यहां पाई जा सकती है । आप ऑनलाइन फोर्थ दुभाषिया का उपयोग भी कर सकते हैं, लेकिन यह बहुत अच्छी तरह से काम नहीं करता है, लेकिन मुस्कराते हुए। मैं gforth का उपयोग करूंगा, जिसे निम्नानुसार स्थापित किया जा सकता है:

sudo apt-get install gforth 

सब कुछ, जैसे ही हमने इसे स्थापित किया है, आप कमांड को चलाकर इंटरेक्टिव मोड में फोर्ट टर्मिनल में शुरू कर सकते हैं:

 gforth 

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

 1 2 + 

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

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

ठीक है, परिचय से आवाज़ लगती है और अब आप इस भाषा में हैलो दुनिया देख सकते हैं:

 ." Hello world" 

यदि आप इस कमांड को इंटरैक्टिव मोड में निष्पादित करते हैं, तो प्रतिक्रिया में हम प्राप्त करते हैं:

 Hello world 

लेकिन वास्तव में, यह बिल्कुल कुछ भी नहीं दिखाता है! सिद्धांत रूप में, किसी भी अन्य प्रोग्रामिंग भाषा में किसी भी हैलो दुनिया की तरह। आइए फोर्थ प्रोग्राम लिखने के कुछ बुनियादी सिद्धांतों पर एक नज़र डालें।

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

 1 2 3 4 

अब, स्टैक से शीर्ष तत्व को निकालने के लिए ऑपरेटर का उपयोग करना ("")। हम स्टैक से सभी आइटम खींचेंगे:

  . . . . 

हमें निम्नलिखित निष्कर्ष मिलते हैं:

 4 3 2 1 ok 

यही है, हमने एक्शन में फिल्म के सिद्धांत को देखा: स्टैक पर डाला गया पहला तत्व स्टैक से निकाला जाने वाला आखिरी था। आइए अब निम्नलिखित अंकगणितीय प्रदर्शन करने का प्रयास करें: (२ + ४) * ५ / १०। परिणामस्वरूप, हमें ३ प्राप्त करना चाहिए। फोर्ट में हम इस ऑपरेशन को इस तरह लिख सकते हैं:

 2 4 + 5 * 10 / . 

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

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

 : POW DUP * . ; 

बस इतना ही, हमने अपने स्वयं के शब्द को परिभाषित किया है, जिसका उपयोग इस तरह किया जा सकता है:

 4 POW 

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

 :POW DUP * . ; 

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

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

  : testif dup 1 = if ." One" else dup 2 = if ." Two" else dup 3 = if ." Three" then then then drop ; 

वैसे, फोर्ट केस असंवेदनशील है, इसलिए डुबकी और डीयूपी एक ही हैं।

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

 1 2 

 < 

 .S 

यहां हमने पहले दो संख्याओं को स्टैक पर रखा, फिर स्टैक के दो ऊपरी तत्वों की तुलना करने के लिए ऑपरेशन किया। वह उन्हें बाहर ले जाती है, उनकी तुलना करती है और परिणाम को ढेर पर रखती है। तीसरा कमांड स्टैक की पूरी सामग्री को प्रदर्शित करता है, जो कि एक एकल: -1 होगा। फोर्थ में माइनस एक बूलियन "सत्य" है और शून्य "झूठी" है।

इसलिए, हम शीर्ष तत्व की नकल करते हैं ताकि इसका उपयोग अगली शाखा में तुलना के लिए किया जा सके। असल में, अगर हम इस तरह लिखते हैं:

 : testif dup 1 = if ." One" else dup 2 = if ." Two" else 3 = if ." Three" then then then ; 

तब हमें एक ही परिणाम मिलता है, लेकिन यह विकल्प स्वीकार नहीं किया जाता है, क्योंकि हम कोड की पठनीयता को कम करते हैं। हालाँकि हमने कोड को दो शब्दों (डुबकी और ड्रॉप (स्टैक के शीर्ष तत्व को हटाना)) से कम कर दिया है, फिर भी हमने पठनीयता कम कर दी है।

अब एक नज़र डालते हैं:

  : doloop 10 0 do cr ." Some text" loop ; 

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

सामान्य तौर पर, हम अब कुछ या कम जटिल लिखने के लिए फोर्ट भाषा के सिंटैक्टिक तत्वों के कुछ सेट के मालिक हैं।

आइए एक शब्द को परिभाषित करें जो किसी दिए गए संख्या के भाज्य की गणना करेगा:

 : FACTORIAL recursive dup 1 > if dup 1 - FACTORIAL * else drop 1 endif ; : OURLOOP swap 1 + swap do i . i ." ! = " i FACTORIAL . cr loop ; 

अब कार्रवाई में हमारे शब्द का प्रयास करें:

 17 0 OURLOOP 

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

यह भाषा मस्तिष्क को अच्छी तरह से दस्तक देती है, उदाहरण के लिए, हास्केल से बदतर प्रोग्रामिंग के विचार की सीमाओं को धक्का देती है। और अंत में, फोर्थ के बारे में एक मजाक:

"मास्टर ऑफ स्पीच मिस्ट्री की जेडी योडा से पता चला है - फोर्ट में यह एक पुराना प्रोग्रामर है