7 आसान चरणों में वाई-कॉम्बिनेटर प्राप्त करना

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

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

चरण 1

प्रारंभिक चरण में, हम अंतर्निहित जावास्क्रिप्ट पुनरावर्तन तंत्र का उपयोग करते हैं।

var fact = function (n) { if (n < 2) return 1; return n * fact(n - 1); }; 

चरण 2

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

 (function (f) { f(f); })(function (f) { f(f); }); 

चलो हमारे factorial फ़ंक्शन के लिए ऊपर दिए गए नमूने का उपयोग करें। हालांकि थोड़ा अंतर है। फैक्टोरियल फ़ंक्शन को एक तर्क मिलता है जो अभी तक ज्ञात नहीं है, इसलिए हम एक ऐसा फ़ंक्शन वापस करना चाहते हैं जो इस तर्क को लेता है। इस फ़ंक्शन का उपयोग factorials की गणना करने के लिए किया जा सकता है। इसके अलावा, यह वही है जो हमारे कार्यान्वयन को एक अनंत लूप का परिणाम नहीं बनाता है।

 var fact = (function (f) { return function (n) { // termination condition if (n < 2) return 1; // because f returns a function, we have a double function call. return n * f(f)(n - 1); }; })(function (f) { return function (n) { // termination condition if (n < 2) return 1; // because f returns a function, we have a double function call. return n * f(f)(n - 1); }; }); 

चरण 3

फिलहाल, हमारे पास कुछ बदसूरत दोहराव है। आइए इसे कुछ हेल्पर फंक्शन recur में छिपाते recur

 var recur = function (f) { return f(f); }; var fact = recur(function (f) { return function (n) { if (n < 2) return 1; // because f returns a function, we have a double function call. return n * f(f)(n - 1); }; }); 

चरण 4

ऊपर दिए गए संस्करण के साथ समस्या दोहरी फ़ंक्शन कॉल है। हम इसे खत्म करना चाहते हैं, ताकि हम पुनरावर्ती संस्करण के साथ समान रूप से फैक्टरियल को लागू कर सकें। हम यह कैसे कर सकते हैं?

हम एक हेल्पर फ़ंक्शन का उपयोग कर सकते हैं जो एक संख्यात्मक तर्क लेता है और एक डबल कॉल करता है। चाल इस हेल्पर फ़ंक्शन को कुछ वातावरण में छोड़ना है जहां f दिखाई दे रहा है ताकि g को f कह सकें।

 var recur = function (f) { return f(f); }; var fact = recur(function (f) { var g = function (n) { return f(f)(n); }; return function (n) { if (n < 2) return 1; // no more double call, g is a function which takes a numeric arg return n * g(n - 1); }; }); 

चरण 5

ऊपर का काम अच्छा है, लेकिन परिभाषा में इतना गन्दा कोड है। हम इसे एक और सहायक कार्य के अंदर छिपा सकते हैं, जिससे केवल तथ्यात्मक की परिभाषा ही रह जाएगी।

 var recur = function (f) { return f(f); }; var wrap = function (h) { return recur(function (f) { var g = function (n) { return f(f)(n); }; return h(g); }); }; var fact = wrap(function (g) { return function (n) { if (n < 2) return 1; return n * g(n - 1); }; }); 

चरण 6

चलो g अंदर की परिभाषा को wrap क्योंकि हम इसे केवल एक बार कहते हैं।

 var recur = function (f) { return f(f); }; var wrap = function (h) { return recur(function (f) { return h(function (n) { return f(f)(n); }); }); }; var fact = wrap(function (g) { return function (n) { if (n < 2) return 1; return n * g(n - 1); }; }); 

चरण 7

अब, यदि हम wrap अंदर recur फ़ंक्शन की परिभाषा को भी एम्बेड करते हैं, तो हम प्रसिद्ध वाई-कॉम्बिनेटर के साथ समाप्त हो जाएंगे।

 var Y = function (h) { return (function (f) { return f(f); })(function (f) { return h(function (n) { return f(f)(n); }); }); }; var fact = Y(function (g) { return function (n) { if (n < 2) return 1; return n * g(n - 1); }; }); 

अंत

मुझे आशा है कि आपको अच्छा लगा होगा।