अनबॉक्स किए गए प्रकारों और कठोरता के बीच संबंध क्या है?

Question

Int# जैसे अनबॉक्स किए गए प्रकार, और f (!x) = ... जैसे सख्त फ़ंक्शन कुछ अलग हैं, लेकिन मुझे वैचारिक समानता दिखाई देती है - वे कुछ तरीकों से थंक्स/आलस्य को अस्वीकार करते हैं। यदि हास्केल ओकैम की तरह सख्त भाषा थी, तो प्रत्येक कार्य सख्त होगा और हर प्रकार अनबॉक्स किया जाएगा। अनबॉक्स किए गए प्रकारों और सख्तता को लागू करने के बीच संबंध क्या है?

Answer 1

बनाम बॉक्स्ड डाटा अनबॉक्स्ड

the heap पर एक closure करने के लिए parametric polymorphism और laziness समर्थन करने के लिए एक सूचक के रूप में समान रूप से प्रतिनिधित्व कर रहे हैं डिफ़ॉल्ट हास्केल डेटा प्रकार से, इस तरह की एक संरचना के साथ:

ये "बॉक्स किए गए" मान हैं। अनबॉक्स किए गए ऑब्जेक्ट को किसी भी संकेत या बंद किए बिना सीधे मूल्य द्वारा दर्शाया जाता है। Int बॉक्स किया गया है, लेकिन Int# अनबॉक्स किया गया है।

लेज़ी की आवश्यकता होती है एक बॉक्स्ड प्रतिनिधित्व महत्व देता है। सख्त मूल्य नहीं हैं: वे या तो ढेर पर पूरी तरह से मूल्यांकन किए गए बंद होने या आदिम अनबॉक्स किए गए संरचनाओं के रूप में प्रतिनिधित्व कर सकते हैं। ध्यान दें कि pointer tagging एक अनुकूलन है जिसे हम बंदरगाह में कन्स्ट्रक्टर को बंद करने के लिए बॉक्स किए गए ऑब्जेक्ट्स पर उपयोग कर सकते हैं।

रिश्ता कठोरता को

आम तौर पर, अनबॉक्स्ड मूल्यों कार्यात्मक भाषा संकलनकर्ता द्वारा एक तदर्थ फैशन में उत्पन्न कर रहे हैं। हास्केल में, हालांकि, unboxed values विशेष हैं।वे:

1. उनके पास एक अलग प्रकार है, #;
2. केवल विशेष स्थानों में उपयोग किया जा सकता है; और
3. वे अनलिफ्ट हैं, इसलिए एक ढेर मूल्य के सूचक के रूप में प्रतिनिधित्व नहीं किया जाता है।

क्योंकि वे अनलिफ्ट हैं क्योंकि वे आवश्यक रूप से सख्त हैं। आलस्य का प्रतिनिधित्व संभव नहीं है।

तो विशेष रूप से अनबॉक्स किए गए प्रकार, जैसे Int#, Double#, वास्तव में मशीन पर डबल या int (सी नोटेशन में) के रूप में दर्शाए जाते हैं।

सख़्ती विश्लेषण

अलग से, GHC नियमित हास्केल प्रकार के strictness analysis करता है। यदि किसी मान का उपयोग सख्त पाया जाता है - यानी यह कभी भी 'अपरिभाषित' नहीं हो सकता है - ऑप्टिमाइज़र नियमित प्रकार के सभी उपयोगों को प्रतिस्थापित कर सकता है (उदाहरण के लिए Int) एक अनबॉक्स किए गए एक (Int#) के साथ, क्योंकि यह जानता है कि Int का उपयोग है हमेशा सख्त, और इस प्रकार अधिक कुशल (और हमेशा सख्त) प्रकार Int# के साथ प्रतिस्थापन सुरक्षित है।

data List a = Empty | Cons !a (List a) 

उसके तत्वों में सख्त है, लेकिन उनमें अनबॉक्स्ड मूल्यों के रूप में प्रतिनिधित्व नहीं करता:

हम कर सकते हैं निश्चित रूप से अनबॉक्स्ड प्रकार के बिना सख्त प्रकार, उदाहरण के लिए, एक तत्व-सख्त बहुरूपी सूची है।

यह सख्त भाषाओं, like OCaml के बारे में गलती को भी इंगित करता है। उन्हें अभी भी बहुरूपता का समर्थन करने की आवश्यकता है, इसलिए वे एक समान प्रतिनिधित्व प्रदान करते हैं, या वे डेटा प्रकार और कार्यों को हर प्रकार के विशेषज्ञ हैं। डिफ़ॉल्ट रूप से जीएचसी समान प्रतिनिधित्व का उपयोग करता है, जैसा ओकैमल करता है, हालांकि जीएचसी अब भी specialize types and functions (सी ++ टेम्पलेट्स की तरह) कर सकता है।

Answer 2

अनबॉक्स किए गए प्रकार आवश्यक रूप से सख्त हैं, लेकिन सभी सख्त मूल्यों को अनिवार्य रूप से अनबॉक्स नहीं किया जाता है।

data Foo a = Foo !a !a 

दो सख्त क्षेत्रों

data Bar a = Bar {-# UNPACK #-} !Int !a 

दो सख्त फ़ील्ड होते है, लेकिन पहले एक अनबॉक्स्ड है।

अंत में, कारण अनबॉक्स्ड प्रकार (जरूरी) सख्त हैं thunk स्टोर करने के लिए के रूप में वे उस बिंदु पर सिर्फ फ्लैट, गूंगा डेटा कर रहे हैं कोई जगह नहीं है।

Answer 3

किसी भी प्रकार के तर्क "सख्त" बनाया जा सकता है, लेकिन केवल अनबॉक्स्ड प्रकार है कि बॉक्स्ड प्रकार इसी है Char#, Int#, Word#, Double# और Float# हैं।

यदि आप सी जैसे निम्न स्तर की भाषाएं जानते हैं, तो यह समझाना आसान है। अनबॉक्स किए गए प्रकार int, double, आदि जैसे हैं, और बॉक्स किए गए प्रकार int*, double* आदि जैसे हैं। जब आपके पास int है, तो आप पहले से ही पूरे मान को जानते हैं क्योंकि यह बिट पैटर्न में दर्शाया गया है, इसलिए, यह नहीं है आलसी। यह भी सख्त होना चाहिए, क्योंकि int के सभी मान मान्य हैं और ⊥ नहीं हैं।

हालांकि, एक int* आप भिन्नता सूचक बाद में वास्तविक मूल्य (इस प्रकार आलसी) प्राप्त करने के लिए चुन सकते हैं को देखते हुए, और यह अमान्य संकेत करना संभव है (यह ⊥ होता है, जैसे गैर-सख्त)।