गैर-आंशिक आलसी मूल्यांकन

Question

मैं वर्तमान में अच्छी प्रस्तुति को पाचन कर रहा हूं हास्केल क्यों सीखें? Keegan McAllister द्वारा। वहां उन्होंने यह कहते हुए minimum हास्केल में समय-जटिलता हे (एन) है कि द्वारा टुकड़ा

minimum = head . sort 

हास्केल के आलसी मूल्यांकन का एक उदाहरण के रूप में उपयोग करता है। हालांकि, मुझे लगता है कि उदाहरण प्रकृति में अकादमिक तरह का है। इसलिए मैं एक और व्यावहारिक उदाहरण मांग रहा हूं जहां यह स्पष्ट रूप से स्पष्ट नहीं है कि इंटरमीडिएट की गणनाओं को हटा दिया गया है।

Answer 1

• क्या आपने कभी एआई लिखा है? क्या यह परेशान नहीं है कि पेड़ ट्रैवर्सल फ़ंक्शन के माध्यम से आपको थ्रेड काटने की जानकारी (जैसे अधिकतम गहराई, आसन्न शाखा की न्यूनतम लागत, या ऐसी अन्य जानकारी) होनी चाहिए? इसका मतलब है कि हर बार जब आप अपनी एआई में सुधार करना चाहते हैं तो आपको एक नया पेड़ ट्रैवर्सल लिखना होगा। वह गूंगा है। आलसी मूल्यांकन के साथ, यह अब कोई समस्या नहीं है: एक बार अपने पेड़ ट्रैवर्सल फ़ंक्शन को एक बार लिखने के लिए, एक विशाल (शायद यहां तक ​​कि अनंत!) गेम पेड़ तैयार करने के लिए, और अपने उपभोक्ता को यह तय करने दें कि इसका कितना उपभोग करना है।

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

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

• यहां एक ऐसा है जो शायद पिछले लोगों की तुलना में थोड़ा अधिक संभावना है। क्या आपने कभी ऐसा समय पाया है जब && और || केवल एकमात्र चीजें नहीं थीं जिन्हें आप शॉर्ट सर्किट करना चाहते थे? मुझे यकीन है कि! उदाहरण के लिए, मुझे Maybe मानों के संयोजन के लिए <|> फ़ंक्शन से प्यार है: यह वास्तव में एक मूल्य है जो इसके तर्कों में से पहला लेता है। तो Just 3 <|> Nothing = Just 3; Nothing <|> Just 7 = Just 7; और Nothing <|> Nothing = Nothing। इसके अलावा, यह शॉर्ट सर्किटिंग है: यदि यह पता चला है कि इसका पहला तर्क Just है, तो यह समझने के लिए आवश्यक गणना करने से परेशान नहीं होगा कि इसका दूसरा तर्क क्या है।

  और <|> भाषा में नहीं बनाया गया है; यह एक पुस्तकालय द्वारा किया जाता है। यही है: आलस्य आपको ब्रांड नए शॉर्ट-सर्किटिंग फॉर्म लिखने की अनुमति देती है। (वास्तव में, हास्केल, (&&) और (||) की छोटी-सर्किटिंग व्यवहार में अंतर्निहित हैं नहीं संकलक जादू: वे मानक पुस्तकालयों में भाषा के शब्दों के साथ साथ उनकी परिभाषा से स्वाभाविक रूप से उत्पन्न होती हैं।)

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

Answer 2

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

Answer 3

यहां एक प्रसिद्ध उदाहरण है जिसे मैंने कल एक और धागे पर पोस्ट किया था। हथौड़ा संख्याएं संख्याएं हैं जिनके पास 5 से बड़े कोई प्रमुख कारक नहीं हैं Ie. उनके पास फॉर्म 2^i * 3^जे * 5^के है। उनमें से पहले 20 कर रहे हैं:

[1,2,3,4,5,6,8,9,10,12,15,16,18,20,24,25,27,30,32,36] 

500000 एक है:

1962938367679548095642112423564462631020433036610484123229980468750 

प्रोग्राम है जो 500000 एक (संगणना का एक संक्षिप्त पल के बाद) मुद्रित है:

merge xxs@(x:xs) yys@(y:ys) = 
    case (x`compare`y) of 
    LT -> x:merge xs yys 
    EQ -> x:merge xs ys 
    GT -> y:merge xxs ys 

hamming = 1 : m 2 `merge` m 3 `merge` m 5 
    where 
    m k = map (k *) hamming 

main = print (hamming !! 499999) 

गैर-आलसी भाषा में उचित गति के साथ उस संख्या की गणना करना थोड़ा अधिक कोड और सिर-खरोंच लेता है। examples here