'कहां' में घोषणाएं - क्या चल रहा है?

Question

QuickCheck Manual पढ़ते समय, मैं निम्न उदाहरण भर में आया था:

गुण monomorphic प्रकार होना चाहिए:

prop_RevRev xs = reverse (reverse xs) == xs 
    where types = xs::[Int] 

पुस्तिका पर कहने के लिए चला जाता है। `पॉलिमॉर्फिक 'गुण, जैसे उपर्युक्त, परीक्षण के लिए उपयोग किए जाने वाले किसी विशेष प्रकार तक सीमित होना चाहिए। यह एक

में एक या अधिक तर्क के प्रकार कहते हुए कि ऐसा करने के लिए सुविधाजनक है जहां प्रकार = (x1 :: t1, x2 :: t2, ...)

खंड। ध्यान दें कि प्रकार एक कीवर्ड नहीं है; यह सिर्फ एक स्थानीय घोषणा है जो x1, x2 आदि के प्रकारों को प्रतिबंधित करने के लिए एक सुविधाजनक स्थान प्रदान करता है

मैंने पहले कभी हास्केल में ऐसी चाल नहीं देखी है। यहां मुझे वास्तव में समस्याएं हैं:

1. टाइप घोषणाओं के लिए यह वाक्यविन्यास क्यों मौजूद है? यह मेरे लिए क्या कर सकता है कि निम्नलिखित नहीं कर सका?

   prop_RevRev :: [Int] -> Bool 
   prop_RevRev xs = reverse (reverse xs) == xs 
   

2. where के इस प्रयोग का गठन प्रकार घोषणाओं के लिए 'विशेष' वाक्य रचना है? या यह लगातार और तार्किक है (और यदि हां, तो कैसे?)?

3. क्या यह उपयोग मानक या पारंपरिक हास्केल है?

Answer 1

where प्रकार घोषणाओं के लिए विशेष वाक्यविन्यास नहीं है। उदाहरण के लिए, इस काम करता है:

prop_RevRev :: [Int] -> Bool 
prop_RevRev xs = ys == xs 
    where ys = reverse (reverse xs) 

और इसलिए इस करता है:

prop_RevRev xs = ys == xs 
    where ys = reverse (reverse xs) 
     ys :: [Int] 

where type = (xs :: [Int])prop_RevRev :: [Int] -> Bool से अधिक का लाभ उत्तरार्द्ध मामले में आप, वापसी प्रकार निर्दिष्ट करने के लिए है कि है पूर्व के मामले में, जबकि संकलक इसे आपके लिए अनुमान लगा सकता है। यदि आप उदाहरण के लिए, एक गैर Boolean संपत्ति थी इस बात करेंगे:

prop_positiveSum xs = 0 < length xs && all (0 <) xs ==> 0 < sum xs 
    where types = (xs :: [Int]) 

Answer 2

यह कोई विशेष सिंटेक्स है, और कुछ समय आप इसे ज़रूरत है, निम्नलिखित मामले में की तरह:

foo :: String -> String 
foo s = show (read s) 

यह रूप खड़ा है, इसे टाइप नहीं किया जा सकता है क्योंकि मान read s के प्रकार की पहचान नहीं की जा सकती है। जो कुछ ज्ञात है वह यह है कि यह शो और रीड का एक उदाहरण होना चाहिए। लेकिन यह प्रकार टाइप हस्ताक्षर में बिल्कुल दिखाई नहीं देता है, इसलिए इसे छोड़ना और बाध्य प्रकार का अनुमान लगाना भी संभव नहीं है। (केवल कोई प्रकार परिवर्तनीय नहीं है जिसे बाधित किया जा सकता है।)

यह ध्यान रखें कि दिलचस्प है क्या read s करता है प्रकार हस्ताक्षर एक read s के लिए देता है पर पूरी तरह से निर्भर करता है, उदाहरण के लिए:

read "Just True" :: (Maybe Bool) 

सफल होगा, जबकि

read "Just True" :: (Maybe Int) 

नहीं होगा।