हास्केल अपवाद केवल आईओ मोनैड के अंदर क्यों पकड़े जा सकते हैं?

Question

क्या कोई बता सकता है कि आईओ मोनैड के बाहर अपवाद क्यों फेंक दिए जा सकते हैं, लेकिन केवल इसके अंदर पकड़ा जा सकता है?

Answer 1

कारणों में से एक denotational semantics of Haskell है। अधिक परिभाषित तर्क पैदावार अधिक परिभाषित मूल्य -

(शुद्ध) हास्केल कार्यों का साफ प्रॉपर्टीज़ में से एक उनके दिष्टता है। यह संपत्ति बहुत महत्वपूर्ण है उदा। पुनरावर्ती कार्यों के बारे में कारण (समझने के लिए लेख पढ़ें) क्यों।

परिभाषा द्वारा अपवाद का नोटेशन नीचे दिया गया है, _|_, दिए गए प्रकार से संबंधित पॉकेट में कम से कम तत्व। इस प्रकार, दिष्टता आवश्यकता को पूरा करने के लिए, निम्न असमानता हास्केल समारोह के किसी भी वाच्यार्थ f के लिए पकड़ करने के लिए की जरूरत है:

f(_|_) <= f(X) 

अब, अगर हम अपवाद पकड़ सकते थे, हम (द्वारा "पहचानने" नीचे इस असमानता को तोड़ सकते थे पकड़ने अपवाद) तथा लौटने अधिक परिभाषित मूल्य:

f x = case catch (seq x True) (\exception -> False) of 
     True -> -- there was no exception 
      undefined 
     False -> -- there was an exception, return defined value 
      42 

यहाँ पूरा काम कर प्रदर्शन है (की आवश्यकता आधार -4 Control.Exception):

import Prelude hiding (catch) 
import System.IO.Unsafe (unsafePerformIO) 
import qualified Control.Exception as E 

catch :: a -> (E.SomeException -> a) -> a 
catch x h = unsafePerformIO $ E.catch (return $! x) (return . h) 

f x = case catch (seq x True) (\exception -> False) of 
     True -> -- there was no exception 
      undefined 
     False -> -- there was an exception, return defined value 
      42 

एक अन्य कारण, जैसा कि टॉमएमडी ने नोट किया, संदर्भित पारदर्शिता तोड़ रहा है। आप बराबर चीजों को बराबर के साथ प्रतिस्थापित कर सकते हैं और एक और जवाब प्राप्त कर सकते हैं। (Denotational भावना में बराबर, यानी वे == भावना में नहीं, एक ही मूल्य को दर्शाते हैं।)

हम यह कैसे करेंगे? निम्नलिखित अभिव्यक्ति पर विचार करें:

let x = x in x 

यह एक गैर-सांत प्रत्यावर्तन है, इसलिए यह कभी नहीं हमें किसी भी जानकारी देता है और इस तरह _|_ द्वारा भी दिखाया जाता है। अगर हम अपवादों को पकड़ने के लिए सक्षम थे, हम समारोह लिख सकता है च जैसे

f undefined = 0 
f (let x = x in x) = _|_ 

(उत्तरार्द्ध हमेशा सख्ती से पालन कार्यों के लिए सच है, क्योंकि हास्केल गैर समाप्त गणना पता लगाने के लिए कोई साधन प्रदान करता है - और सिद्धांत रूप में नहीं कर सकते हैं, Halting problem की वजह से।)

Answer 2

क्योंकि अपवाद referential transparency तोड़ सकता है।

आप शायद अपवाद है कि वास्तव में इनपुट के प्रत्यक्ष परिणाम हैं के बारे में बात कर रहे हैं। उदाहरण के लिए:

head [] = error "oh no!" -- this type of exception 
head (x:xs) = x 

आप इस तरह त्रुटियों को पकड़ने के लिए सक्षम नहीं होने का रोना रोते रहे हैं तो मैं तुम्हें करने के लिए दावा है कि कार्यों error या किसी अन्य अपवादों के नहीं भरोसा किया जाना चाहिए, लेकिन इसके बजाय (एक उचित वापसी प्रकार का उपयोग करना चाहिए Maybe, Either, या शायद MonadError)। यह आपको असाधारण स्थिति से अधिक स्पष्ट तरीके से निपटने के लिए मजबूर करता है।

ऊपर (और क्या अपने प्रश्न के पीछे समस्या होती है) के विपरीत, अपवाद जैसे स्मृति की स्थिति है कि मूल्य का अभिकलन किया जा रहा है पूरी तरह से स्वतंत्र हैं से बाहर के रूप में संकेतों से हो सकता है। यह स्पष्ट रूप से एक शुद्ध अवधारणा नहीं है और आईओ में रहना चाहिए।

Answer 3

मैं अपने विवरण में गलत हो सकता है, लेकिन इस तरह मैं यह समझ है।

चूंकि कार्य हास्केल में शुद्ध हैं, इसलिए संकलक को उनके इच्छित किसी भी क्रम में उनका मूल्यांकन करने का अधिकार है और यह अभी भी एक ही परिणाम उत्पन्न करता है। उदाहरण के लिए, दिए गए कार्य:

square :: Int -> Int 
square x = x * x 

अभिव्यक्ति square (square 2) अलग अलग तरीकों से मूल्यांकन किया जा सकता, लेकिन यह हमेशा एक ही परिणाम है जो 16

है अगर हम कहीं और से square कॉल करने के लिए कम कर देता है:

test x = if x == 2 
     then square x 
     else 0 

square x का मूल्यांकन बाद में मूल्यांकन किया जा सकता है, जब test फ़ंक्शन को वास्तव में आवश्यक होने पर "बाहर" किया जा सकता है। उस पल में कॉल स्टैक जावा से कहने की अपेक्षा से बिल्कुल अलग हो सकता है।

तो अगर हम square द्वारा फेंकने वाले संभावित अपवाद को पकड़ना चाहते हैं, तो आपको catch भाग कहां रखना चाहिए?