आभासी पारदर्शिता के साथ आलस्य क्यों अच्छी तरह से जाती है?

Question

मैं एक हास्केल ट्यूटोरियल पढ़ रहा था (आपको एक हास्केल सीखें) जिसमें लेखक ने कहा था कि आलस्यता पारदर्शी पारदर्शिता के साथ अच्छी तरह से चलती है। अधिक पढ़ने और कुछ खोज करने के बाद, मुझे अभी भी समझ में नहीं आता क्यों। ध्यान दें कि मैं समझता हूं कि रेफरेंसियल पारदर्शिता और आलस्य के बारे में क्या बढ़िया है, लेकिन यह एक साथ है जो मुझे परेशान कर रहा है।

क्या दोनों के संयोजन का कोई विशेष लाभ है?

या शायद लेखक सिर्फ यह कहना चाहते थे कि वे दोनों अच्छे हैं और अस्पष्ट रूप से व्यक्त किए गए हैं?

Answer 1

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

long start = System.currentTimeMillis(); //get the start time 
runBenchmarkFunction(); 
System.out.println("Run took " + (System.currentTimeMillis() - start) + " ms"); 

अब एक आलसी भाषा, पहली पंक्ति के evalutation स्थगित होगा क्योंकि शुरुआत केवल तीसरी पंक्ति के लिए आवश्यक है। तो परिणाम 0 होगा (या इसके बहुत करीब)। शायद वह नहीं है जो आप चाहते हैं। उस परेशानी का कारण यह होगा कि System.currentTimeMillis संदर्भित पारदर्शी नहीं है। आपको उस मामले में कोई समस्या नहीं होगी यदि यह पाप या एलएन जैसे "गणितीय अर्थ" में एक फ़ंक्शन था, जो संदर्भित पारदर्शी हैं।

Answer 2

संदर्भित पारदर्शिता का अर्थ है कि फ़ंक्शन हमेशा एक ही इनपुट को उसी इनपुट को वापस कर देगा। तो अगर कोई फर्क नहीं पड़ता कि समारोह आलसी या सख्त है। आलसी कार्य भविष्य में किसी अज्ञात समय पर अपने आउटपुट की गणना करेगा लेकिन संदर्भित पारदर्शिता के कारण आपको गारंटी दी जाती है कि आउटपुट हमेशा दिए गए इनपुट के लिए समान होगा।

तो एक तरह से, रेफरेंसियल पारदर्शिता आलसी कार्यों की शुद्धता का आश्वासन देती है।

Answer 3

इस पायथन कोड पर विचार करें, जहां एक जेनरेटर का उपयोग अनंत अनुक्रम की आलस्य गणना करने के लिए किया जाता है। वैश्विक स्थिति के उपयोग के कारण इसकी कोई पारदर्शी पारदर्शिता नहीं है, इसलिए जनरेटर का एक कॉलर यह सुनिश्चित नहीं कर सकता है कि वे जो परिणाम प्राप्त कर रहे हैं वह किसी अन्य घटना से प्रभावित नहीं हुआ है।

foo = 0 

def foo_sequence(): 
    global foo 
    while True: 
     foo += 1 
     yield foo 

>>> generator = foo_sequence() 
>>> generator.next() 
1 
>>> generator.next() 
2 
>>> foo = 5 
>>> generator.next() 
6 

इस मामले में, कॉलर ऐसी घटनाओं को रोकने के लिए परमाणु रूप से संपूर्ण अनुक्रम उत्पन्न करना पसंद करेंगे। इसलिए, रेफरेंसियल पारदर्शिता की कमी (इस प्रदूषित उदाहरण में) आलस्य को अवांछित बनाता है।