लैम्ब्डा और क्लोजर के आसपास बहुत भ्रम है, यहां तक कि इस स्टैकऑवरफ्लो प्रश्न के उत्तर में भी। यादृच्छिक प्रोग्रामर से पूछने के बजाय जिन्होंने कुछ प्रोग्रामिंग भाषाओं या अन्य क्लूलेस प्रोग्रामर के साथ अभ्यास से बंद होने के बारे में सीखा, स्रोत (जहां यह सब शुरू हुआ) की यात्रा करें। और चूंकि लैम्ब्डा और क्लोजर अलोंजो चर्च द्वारा आविष्कार किए गए लैम्ब्डा कैलकुलस से आते हैं , इसलिए 30 के दशक में पहले इलेक्ट्रॉनिक कंप्यूटर भी मौजूद थे, यही वह स्रोत है जिसके बारे में मैं बात कर रहा हूं।
लैम्ब्डा कैलकुलस दुनिया की सबसे सरल प्रोग्रामिंग भाषा है। केवल एक चीज जो आप इसमें कर सकते हैं: do
- आवेदन: एक अभिव्यक्ति को दूसरे पर लागू करना, निरूपित करना
f x।
(इसे फ़ंक्शन कॉल के रूप में सोचें , फ़ंक्शन कहां fहै और xइसका एकमात्र पैरामीटर है)
- निर्देश: एक चिन्ह को एक चिह्न में रखने के लिए यह दर्शाता है कि यह प्रतीक सिर्फ एक "स्लॉट" है, एक खाली बॉक्स जो मूल्य से भरा है, एक "चर" जैसा है। यह एक ग्रीक पत्र
λ(लैम्ब्डा), फिर प्रतीकात्मक नाम (उदाहरण x), फिर .अभिव्यक्ति से पहले एक बिंदु को जोड़कर किया जाता है। यह तब एक पैरामीटर की अपेक्षा फ़ंक्शन को अभिव्यक्ति में परिवर्तित करता है । उदाहरण के लिए: अभिव्यक्ति लेता है और बताता है कि इस अभिव्यक्ति में प्रतीक एक बाध्य चर है - यह एक मान के साथ प्रतिस्थापित किया जा सकता है जिसे आप एक पैरामीटर के रूप में आपूर्ति करते हैं।
ध्यान दें कि फ़ंक्शन इस तरह परिभाषित किया गया है अनाम है
λx.x+2x+2x
- इसका कोई नाम नहीं है, इसलिए आप इसे अभी तक संदर्भित नहीं कर सकते हैं, लेकिन आप इसे तुरंत कॉल कर सकते हैं (आवेदन याद है?) इसे उस पैरामीटर की आपूर्ति करके, जिसके लिए यह इंतजार कर रहा है: इस तरह (λx.x+2) 7। तब अभिव्यक्ति (इस मामले में एक शाब्दिक मूल्य) 7को लागू लैम्ब्डा xके उप- रूप में प्रतिस्थापित किया जाता है x+2, इसलिए आपको प्राप्त होता है 7+2, जो तब 9सामान्य अंकगणितीय नियमों द्वारा कम हो जाता है।
इसलिए हम रहस्यों में से एक समाधान कर लिया है:
लैम्ब्डा है गुमनाम समारोह , ऊपर के उदाहरण से λx.x+2।
विभिन्न प्रोग्रामिंग भाषाओं में, कार्यात्मक अमूर्त (लैम्ब्डा) के लिए वाक्यविन्यास भिन्न हो सकते हैं। उदाहरण के लिए, जावास्क्रिप्ट में यह इस तरह दिखता है:
function(x) { return x+2; }
और आप इसे इस तरह से कुछ पैरामीटर पर तुरंत लागू कर सकते हैं:
(function(x) { return x+2; })(7)
या आप इस अनाम फ़ंक्शन (लैम्बडा) को कुछ चर में स्टोर कर सकते हैं:
var f = function(x) { return x+2; }
जो प्रभावी रूप से इसे एक नाम देता है f, जिससे आप इसे संदर्भित कर सकते हैं और बाद में कई बार कॉल कर सकते हैं, जैसे:
alert( f(7) + f(10) ); // should print 21 in the message box
लेकिन आपको इसे नाम नहीं देना था। आप इसे तुरंत कॉल कर सकते हैं:
alert( function(x) { return x+2; } (7) ); // should print 9 in the message box
LISP में, लंबोदर इस तरह से बनाए जाते हैं:
(lambda (x) (+ x 2))
और आप ऐसे लैम्बडा को तुरंत एक पैरामीटर पर लागू करके कॉल कर सकते हैं:
( (lambda (x) (+ x 2)) 7 )
ठीक है, अब दूसरे रहस्य को हल करने का समय है: एक
बंद क्या है । ऐसा करने के लिए, आइए हम लैम्ब्डा अभिव्यक्तियों में
प्रतीकों (
चर ) के बारे में बात करते हैं ।
जैसा कि मैंने कहा, क्या लैम्ब्डा अमूर्त करता है बाध्यकारी अपने उपसूचक में एक प्रतीक है, इसलिए है कि यह एक substitutible हो जाता है पैरामीटर । इस तरह के प्रतीक को बाध्य कहा जाता है । लेकिन क्या होगा अगर अभिव्यक्ति में अन्य प्रतीक हैं? उदाहरण के लिए λx.x/y+2:। इस अभिव्यक्ति में, प्रतीक xलैंबडा एब्स्ट्रैक्शन से λx.पहले से बंधा हुआ है। लेकिन दूसरा प्रतीक, yबाध्य नहीं है - यह मुफ़्त है । हम नहीं जानते कि यह क्या है और यह कहां से आता है, इसलिए हम यह नहीं जानते कि इसका क्या अर्थ है और यह किस मूल्य का प्रतिनिधित्व करता है, और इसलिए हम उस अभिव्यक्ति का मूल्यांकन नहीं कर सकते जब तक कि हम yइसका क्या मतलब निकालते हैं ।
वास्तव में, वही अन्य दो प्रतीकों के साथ जाता है, 2और +। यह सिर्फ इतना है कि हम इन दो प्रतीकों से इतने परिचित हैं कि हम आमतौर पर भूल जाते हैं कि कंप्यूटर उन्हें नहीं जानता है और हमें यह बताने की आवश्यकता है कि उन्हें कहीं और परिभाषित करने का क्या मतलब है, जैसे कि एक पुस्तकालय या भाषा में।
आप मुक्त प्रतीकों के बारे में सोच सकते हैं कि कहीं और, अभिव्यक्ति के बाहर, इसके "आसपास के संदर्भ" में, जिसे इसके पर्यावरण कहा जाता है । पर्यावरण एक बड़ी अभिव्यक्ति हो सकती है कि यह अभिव्यक्ति का एक हिस्सा है (जैसा कि क्यूई-गोन जिन ने कहा: "हमेशा एक बड़ी मछली होती है";)), या कुछ पुस्तकालय में, या भाषा में ही (एक आदिम के रूप में )।
इससे हम लैम्ब्डा के भावों को दो श्रेणियों में विभाजित कर सकते हैं:
- बंद भाव: इन भावों में होने वाला प्रत्येक प्रतीक किसी न किसी लैंबडा अमूर्तन से बंधा होता है । दूसरे शब्दों में, वे आत्म-निहित हैं ; उन्हें मूल्यांकन के लिए किसी भी आसपास के संदर्भ की आवश्यकता नहीं है। उन्हें कॉम्बिनेटर भी कहा जाता है ।
- खुली अभिव्यक्तियाँ: इन अभिव्यक्तियों में कुछ प्रतीक बंधे हुए नहीं हैं - अर्थात् , उनमें से कुछ प्रतीक मुक्त हैं और उन्हें कुछ बाहरी जानकारी की आवश्यकता है, और इस प्रकार उनका मूल्यांकन तब तक नहीं किया जा सकता जब तक आप इन प्रतीकों की परिभाषाओं की आपूर्ति नहीं करते।
आप पर्यावरण की आपूर्ति करके एक खुली मेमने की अभिव्यक्ति को बंद कर सकते हैं , जो इन सभी मुक्त प्रतीकों को कुछ मूल्यों (जो संख्या, तार, अनाम फ़ंक्शन उर्फ लंबोदा, जो भी हो ...) से बांधकर परिभाषित कर सकते हैं।
और यहाँ आता है बंद हिस्सा: बंद एक की लैम्ब्डा अभिव्यक्ति बाहरी संदर्भ (पर्यावरण) है कि करने के लिए मान देना में परिभाषित प्रतीकों के इस विशेष सेट है मुक्त प्रतीकों इस अभिव्यक्ति में, अब और उन्हें गैर मुक्त बना रही है। यह एक खुली मेमने की अभिव्यक्ति को बदल देता है , जिसमें अभी भी कुछ "अपरिभाषित" मुक्त प्रतीक शामिल हैं, एक बंद में , जिसमें अब कोई भी मुफ्त प्रतीक नहीं है।
उदाहरण के लिए, यदि आप निम्नलिखित लैम्ब्डा अभिव्यक्ति है: λx.x/y+2, प्रतीक x, स्वाभाविक है, जबकि प्रतीक yनि: शुल्क है, इसलिए अभिव्यक्ति है openऔर मूल्यांकन नहीं किया जा सकता जब तक कि आप कहते हैं कि क्या yअर्थ है (और साथ ही +और 2है, जो भी स्वतंत्र हैं)। लेकिन मान लीजिए कि आपके पास भी ऐसा माहौल है:
{ y: 3,
+: [built-in addition],
2: [built-in number],
q: 42,
w: 5 }
यह पर्यावरण के लिए सभी "अपरिभाषित" (मुक्त) हमारे लैम्ब्डा अभिव्यक्ति से प्रतीकों के लिए आपूर्ति परिभाषाओं ( y, +, 2), और कई अतिरिक्त प्रतीकों ( q, w)। जिन प्रतीकों को हमें परिभाषित करने की आवश्यकता है, वे पर्यावरण के सबसेट हैं:
{ y: 3,
+: [built-in addition],
2: [built-in number] }
और यह ठीक हमारे लैम्ब्डा अभिव्यक्ति का समापन है:>
दूसरे शब्दों में, यह एक खुली मेमने की अभिव्यक्ति को बंद कर देता है । यह वह जगह है जहां पहली बार नाम बंद हुआ था, और यही कारण है कि इस धागे में इतने सारे लोगों के जवाब बहुत सही नहीं हैं: पी
तो उनसे गलती क्यों हुई? उनमें से बहुत से लोग यह क्यों कहते हैं कि स्मृति में कुछ डेटा संरचनाएं बंद हो जाती हैं, या भाषाओं की कुछ विशेषताएं जो वे उपयोग करती हैं, या वे मेमनों के साथ बंद होने को भ्रमित क्यों करती हैं? : पी
ठीक है, सन / ओरेकल, माइक्रोसॉफ्ट, गूगल आदि के कॉर्पोरेट बाज़ार को दोष देना है, क्योंकि यही उन्होंने अपनी भाषाओं (जावा, सी #, गो आदि) में इन निर्माणों को कहा है। वे अक्सर "क्लोजर" कहते हैं जो कि केवल लंबोदर माना जाता है। या वे एक विशेष तकनीक को "क्लोजर" कहते हैं जिसका उपयोग वे लेक्सिकल स्कूपिंग को लागू करने के लिए करते थे, अर्थात्, यह तथ्य कि एक फ़ंक्शन वैरिएबल तक पहुंच सकता है जिसे इसकी परिभाषा के समय इसके बाहरी दायरे में परिभाषित किया गया था। वे अक्सर कहते हैं कि फ़ंक्शन इन चरों को "घेरता है", जो बाहरी फ़ंक्शन के पूरा होने के बाद उन्हें नष्ट होने से बचाने के लिए उन्हें कुछ डेटा संरचना में कैप्चर करता है। लेकिन यह सिर्फ बनावटी पोस्ट फैक्टम "लोकगीत व्युत्पत्ति" और विपणन है, जो केवल चीजों को और अधिक भ्रमित करता है,
और यह इस तथ्य के कारण भी बदतर है कि वे जो कहते हैं, उसमें हमेशा थोड़ी सच्चाई होती है, जो आपको इसे झूठे रूप में आसानी से खारिज करने की अनुमति नहीं देता है: पी मुझे समझाएं:
यदि आप लैम्बदास का उपयोग करने वाली भाषा को प्रथम श्रेणी के नागरिकों के रूप में लागू करना चाहते हैं, तो आपको उन्हें अपने आस-पास के संदर्भ में परिभाषित प्रतीकों (जो आपके लैम्ब्डा में मुफ्त चर का उपयोग करना है) का उपयोग करने की अनुमति देने की आवश्यकता है। और ये प्रतीक तब भी होना चाहिए जब आसपास का फ़ंक्शन वापस आ जाए। समस्या यह है कि ये प्रतीक फ़ंक्शन के कुछ स्थानीय भंडारण (आमतौर पर कॉल स्टैक पर) से बंधे होते हैं, जो फ़ंक्शन के वापस आने पर अब और नहीं होगा। इसलिए, एक लैम्ब्डा के लिए जिस तरह से आप उम्मीद करते हैं, उसे काम करने के लिए, आपको किसी भी तरह से इन सभी मुक्त चर को अपने बाहरी संदर्भ से "कैप्चर" करने की आवश्यकता है और बाद में भी बाहरी संदर्भ के चले जाने पर उन्हें बचाएंगे। यही है, आपको क्लोजर खोजने की आवश्यकता हैआपके लैम्ब्डा (इन सभी बाहरी वेरिएबल्स का उपयोग करता है) और इसे कहीं और स्टोर करें (या तो कॉपी बनाकर, या उनके लिए जगह तैयार करके, स्टैक पर कहीं और)। इस लक्ष्य को प्राप्त करने के लिए आप जिस वास्तविक विधि का उपयोग करते हैं, वह आपकी भाषा का "कार्यान्वयन विवरण" है। यहां जो महत्वपूर्ण है, वह बंद है , जो आपके लंबो के वातावरण से मुक्त चर का सेट है जिसे कहीं न कहीं सहेजने की आवश्यकता है।
लोगों को वास्तविक डेटा संरचना को कॉल करना शुरू करने में बहुत समय नहीं लगा, जो वे अपनी भाषा के कार्यान्वयन में उपयोग करने के लिए क्लोजर "बंद" के रूप में लागू करते हैं। संरचना आमतौर पर कुछ इस तरह दिखती है:
Closure {
[pointer to the lambda function's machine code],
[pointer to the lambda function's environment]
}
और इन डेटा संरचनाओं को अन्य कार्यों के मापदंडों के रूप में पास किया जा रहा है, कार्यों से लौटाया गया है, और चर में संग्रहीत किया गया है, लैम्ब्डा का प्रतिनिधित्व करने के लिए, और उन्हें अपने संलग्न वातावरण के साथ-साथ मशीन कोड को उस संदर्भ में चलाने के लिए अनुमति देता है। लेकिन यह सिर्फ एक रास्ता (कई में से एक) के लिए लागू बंद, नहीं बंद ही।
जैसा कि मैंने ऊपर बताया, लैम्ब्डा एक्सप्रेशन को बंद करना इसके वातावरण में परिभाषाओं का सबसेट है जो लैम्बडा एक्सप्रेशन में निहित फ्री वैरिएबल्स को वैल्यू देते हैं, एक्सप्रेशन को प्रभावी रूप से बंद करते हैं (एक ओपन लैम्ब्डा एक्सप्रेशन को बदलते हुए, जिसका मूल्यांकन अभी तक नहीं किया जा सकता है, एक बंद लैम्ब्डा अभिव्यक्ति, जिसे तब मूल्यांकन किया जा सकता है, क्योंकि इसमें निहित सभी प्रतीकों को अब परिभाषित किया गया है)।
और कुछ भी नहीं बस एक "कार्गो पंथ" और प्रोग्रामर्स और भाषा विक्रेताओं के "वू-डू जादू" है जो इन धारणाओं की वास्तविक जड़ों से अनजान हैं।
मैं आशा करता हूँ कि यह आपके प्रश्नों का उत्तर देगा। लेकिन अगर आपके पास कोई अनुवर्ती प्रश्न थे, तो उन्हें टिप्पणियों में पूछने के लिए स्वतंत्र महसूस करें, और मैं इसे बेहतर तरीके से समझाने की कोशिश करूंगा।