कार्यात्मक प्रोग्रामिंग भाषाओं को कचरा संग्रह की आवश्यकता क्यों है?

Question

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

संपादित करें: यहां ले जाया गया /programming/39440412/why-do-functional-programming-languages-require-garbage-collection

Comments

बिल्ली प्रोग्रामिंग भाषा एक समारोह, ढेर आधारित भाषा का एक उदाहरण की तरह दिखता है।

— पेट्र पुडलक

यह वह जगह है नहीं एक शोध के स्तर सवाल है, के रूप में कचरा संग्रहण (यह के लिए की जरूरत है और साथ ही) भाषाओं प्रोग्रामिंग पर स्नातक पाठ्यक्रम में शामिल है। कृपया cs.stackexchange.com

— Andrej Bauer

मेरी गलती। क्या आप मेरे प्रश्न का उत्तर जानते हैं?

— निकोलस ग्रासेव्स्की

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

— cody

$\lambda$

Answer 1

फ़ंक्शन मानों और कॉल-बाय-वैल्यू मूल्यांकन का प्रतिनिधित्व करने के लिए क्लोजर का उपयोग करके एक मानक कार्यान्वयन रणनीति की पसंद पर निम्नलिखित सभी टिप्पणियों का प्रीमियर किया जाता है:

1. शुद्ध लैम्ब्डा कैलकुलस के लिए, कचरा संग्रहण आवश्यक नहीं है। ऐसा इसलिए है क्योंकि ढेर में चक्रों को बनाना संभव नहीं है: प्रत्येक नव-आबंटित मूल्य में केवल पहले से आवंटित मूल्यों के संदर्भ हो सकते हैं, और इसलिए मेमोरी ग्राफ़ एक डीएजी बनाता है - इसलिए संदर्भ गिनती स्मृति का प्रबंधन करने के लिए पर्याप्त है।

2. अधिकांश कार्यान्वयन दो कारणों से संदर्भ गिनती का उपयोग नहीं करते हैं।

   1. वे पॉइंटर प्रकार (जैसे, refएमएल में टाइप कंस्ट्रक्टर) का समर्थन करते हैं, और ढेर में सही चक्र का गठन किया जा सकता है।
   2. संदर्भ गणना कचरा संग्रहण की तुलना में बहुत कम कुशल है, क्योंकि
      • यह संदर्भ मायने रखता है, और रखने के लिए बहुत अधिक अतिरिक्त स्थान की आवश्यकता है
      • गणना को अद्यतन करना आमतौर पर व्यर्थ काम है, और
      • काउंट्स के लिए अद्यतन लेखन विवाद का एक गुच्छा बनाते हैं जो समानांतर प्रदर्शन को मारता है।

3. रेखीय रूप से टाइप की गई भाषाएं संदर्भ गणना को समाप्त कर सकती हैं (अनिवार्य रूप से क्योंकि गिनती 0-1 हैं: या तो मूल्य में इसका एक संदर्भ है या यह मृत है और इसे मुक्त किया जा सकता है)।

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

5. आप एक "स्पेगेटी स्टैक" के साथ एक स्टैक को बदलकर सही एसिम्पोटिक्स प्राप्त कर सकते हैं (यानी, ढेर को एक लिस्ट में लिंक की गई सूची के रूप में लागू करें, ताकि आप आवश्यकतानुसार मृत फ़्रेमों को काट सकें)।

6. यदि आप एक वास्तविक स्टैक अनुशासन चाहते हैं, तो आप "ऑर्डर किए गए तर्क" (अनिवार्य रूप से रैखिक प्रकार के माइनस एक्सचेंज) के आधार पर टाइप सिस्टम का उपयोग कर सकते हैं।

Comments

(2) के लिए और अधिक मूल कारण नहीं है कि - यहां तक ​​कि अवलोकन योग्य प्रभावों के बिना भी - कार्यान्वयन (पारस्परिक) पुनरावृत्ति के लिए एक कुशल ऑपरेटर चाहते हैं, यानी, जो वास्तव में ढेर में एक चक्र बनाता है?

— एंड्रियास रॉसबर्ग

@andreasrossberg: मैंने इसका उल्लेख करने के बारे में सोचा, लेकिन इसे छोड़ दिया क्योंकि आप पुनरावृत्ति के लिए वाई कॉम्बिनेटर का उपयोग कर सकते हैं।

— नील कृष्णस्वामी