Haskell की Prelude.read वापसी क्यों नहीं हो सकती है?

Question

क्या Prelude.read का प्रकार एक अच्छा कारण है

read :: Read a => String -> a

Maybeमूल्य वापस करने के बजाय ?

read :: Read a => String -> Maybe a

चूंकि तार पारगम्य हास्केल होने में विफल हो सकता है, क्या उत्तरार्द्ध अधिक प्राकृतिक नहीं होगा?

या यहां तक ​​कि एक Either String a, जहां Leftमूल स्ट्रिंग शामिल नहीं होगी अगर यह पार्स नहीं किया था, और Rightयदि ऐसा हुआ तो परिणाम?

संपादित करें:

मैं दूसरों को मेरे लिए एक संगत आवरण लिखने की कोशिश नहीं कर रहा हूँ। बस यह सुनिश्चित करने के लिए आश्वस्त है कि ऐसा करना सुरक्षित है।

Comments

कोई takeस्वीकार क्यों नहीं करता Num a => a? fmapसूचियों का एक विशेष मामला क्यों है ? उदाहरणों के Functorलिए क्यों आवश्यक नहीं है Monad? मुझे उम्मीद है कि उत्तर इन और संबंधित प्रश्नों के उत्तर के समान होगा।

ठीक है, इसीलिए मैंने इसे वैसे ही किया जैसे मैंने विकल्प को खुला छोड़ दिया कि कोई अच्छा कारण नहीं है। हालांकि मुझे यह भी संदेह है कि आपके द्वारा दिए गए प्रसिद्ध उदाहरणों की तरह, यह नहीं हो सकता है, यह सुनिश्चित करने के लायक है कि मेरे स्वयं के आवरण को लिखने से अप्रत्याशित समस्याएं पैदा नहीं होंगी।

— बिलाल बरकत

मुझे उम्मीद है कि readMaybeजल्द ही एक समारोह जोड़ा जाएगा।

— अगस्त

अच्छे अंक @delnan, लेकिन नहीं takeहोना चाहिए Integral n => n -> [a] -> [a]?

— डौग मैकलीन

@DougMcClean: हाँ, यह वास्तव में होना चाहिए Integral, न कि Numमस्तिष्क का मस्सा ।

Answer 1

संपादित करें : GHC 7.6 के अनुसार, बेस पैकेज में मॉड्यूल में readMaybeउपलब्ध है Text.Read, साथ में readEither: http://hackage.haskell.org/packages/archive/base/latest/doc/html/Text-Read.html#v readMaybe

---

बड़ा अच्छा सवाल! पढ़ने का प्रकार कभी भी जल्द ही नहीं बदल रहा है क्योंकि यह बहुत सारी चीजों को तोड़ देगा। हालांकि, एक होना चाहिएmaybeRead फ़ंक्शन ।

क्यों नहीं है? इसका उत्तर "जड़ता" है। वहाँ एक था '08 में चर्चा जो "असफल" पर चर्चा से पटरी से उतर गई। "

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

इस चर्चा को भी देखें ।

व्यक्तिगत रूप से, मैं सुरक्षित पैकेज से संस्करण का उपयोग करता हूं ।

Answer 2

हाँ, यह एक रीड फंक्शन के साथ काम करेगा जो शायद लौटता है। आप खुद एक बना सकते हैं:

readMaybe :: (Read a) => String -> Maybe a
readMaybe s = case reads s of
              [(x, "")] -> Just x
              _ -> Nothing

Comments

धन्यवाद! मुझे आशा है कि संपादन कृतघ्न नहीं है! :) बस यह स्पष्ट करना चाहता हूं कि मैं आलस्य से बाहर नहीं पूछ रहा हूं ...

— बिलाल बरकत

यदि @augustss इसे प्रदान नहीं कर सकता है, तो बेहतर उत्तर मौजूद नहीं हो सकता है।

— जॉन एल

मुझे नहीं लगता कि मूल डिज़ाइन में कभी संस्करण की चर्चा की गई थी। इनमें से कई चीजें अनुभव से स्पष्ट हो जाती हैं, लेकिन भविष्यवाणी करना कठिन हो सकता है।

— अगस्त

कारण है कि रिटर्न एक सूची पढ़ता मामले में जहां कई वैध पार्स करता है देखते हैं के लिए है। हो सकता है कि मामला पढ़े और पढ़े जाने के बीच का हो।

— क्रिस कुक्लेविक

मुझे लगता है कि इसके लिए Read aटाइपक्लैश की आवश्यकता है :readMaybe :: Read a => String -> Maybe a

— डेविड टीचप

Answer 3

जड़ता और / या अंतर्दृष्टि को बदलने के अलावा, एक और कारण यह हो सकता है कि यह सौंदर्यशास्त्रीय रूप से एक ऐसा फ़ंक्शन है जो एक प्रकार के व्युत्क्रम के रूप में कार्य कर सकता है show। यही कारण है, आप चाहते हैं कि read . showपहचान (प्रकार जो का एक उदाहरण हैं के लिए है Showऔर Read) और कहा कि show . readकी सीमा पर पहचान है show(यानीshow . read . show == show )

समरूपता Maybeको readतोड़ने के प्रकार में होने के साथ show :: a -> String।

Comments

एक नया कोण जोड़ने के लिए धन्यवाद! यह समझ आता है। लेकिन उस सफाई को हासिल करने के लिए, "पार्सएबलस्ट्रीमिंग" कहने के लिए, शो और रीड को एक अलग प्रकार का उत्पादन करने का कोई मतलब नहीं होगा?

— बिलाल बराकत

@ बिलाल बरकत: अलग प्रकार का हो सकता है newtype ValidShow a = ValidShow String। प्रेत प्रकार इसे और अधिक सुरक्षित बनाता है।

— येरचू 21

यह एक दिलचस्प बिंदु है, लेकिन अंततः, एक झूठी समरूपता है। प्रोग्रामर को सौंदर्यशास्त्र पर शुद्धता का मूल्य होना चाहिए।

— मैट फेनविक

@yairchu यह मेरे लिए तुरंत स्पष्ट नहीं था कि आपके पास प्रेत प्रकार के बारे में क्या था, इसलिए मैं स्पष्ट करूंगा कि यदि कोई अन्य व्यक्ति भ्रमित था, तो मैं ऐसा नहीं था। आप कुछ इस तरह का इरादा रखते हैं showThing :: Show a => a -> ValidShow aऔर readThing :: Read a => ValidShow a -> aइसलिए कि जिस प्रकार की चीज़ दिखाई गई थी उसे वैलिदशो ऑब्जेक्ट में याद किया जाता है। इस तरह आप लिख नहीं सकते readThing (showThing True) :: String।

— 20

Answer 4

जैसा कि @augustss ने बताया है, आप अपना स्वयं का सुरक्षित रीड फंक्शन बना सकते हैं। हालाँकि, वह readMaybeपूरी तरह से पढ़ने के अनुरूप नहीं है, क्योंकि यह एक स्ट्रिंग के अंत में व्हाट्सएप को अनदेखा नहीं करता है। (मैंने एक बार यह गलती की थी, मुझे संदर्भ याद नहीं है)

हास्केल 98 रिपोर्ट में पढ़ने की परिभाषा को देखते हुए , हम इसे लागू करने के लिए संशोधित कर सकते हैं जो readMaybeकि पूरी तरह से सुसंगत है read, और यह बहुत असुविधाजनक नहीं है क्योंकि यह उन सभी कार्यों पर निर्भर करता है जो प्रस्तावना में परिभाषित किए गए हैं:

readMaybe        :: (Read a) => String -> Maybe a
readMaybe s      =  case [x | (x,t) <- reads s, ("","") <- lex t] of
                         [x] -> Just x
                         _   -> Nothing

Comments

धन्यवाद! +1 मुझे व्हाट्सएप के मुद्दे के बारे में सचेत करने के लिए, जो पहले स्पष्ट नहीं किया गया था।

— बिलाल बरकत

ध्यान दें कि यदि आप safeपैकेज का उपयोग करते हैं , तो आपको readMaybeउपलब्ध संस्करण का एक सही संस्करण मिलता है (इसे कहा जाता है readMayऔर यह इस संस्करण के समान है।

— नील मिशेल

Answer 5

यह कार्य (जिसे कहा जाता है readMaybe) अब हास्केल प्रस्तावना में है! (वर्तमान बेस के रूप में - 4.6)

Comments

खैर, जुड़ा हुआ पाठ कहता है कि यह Text.Read में है और Prelude में नहीं (मई बदल गया है), हालांकि, इसने अभी भी मेरी मदद की!

— कपिचु