हास्केल डेटा कन्स्ट्रक्टर में इनपुट चेक

Question

मैं हास्केल डेटा कन्स्ट्रक्टर में इनपुट चेक कैसे जोड़ सकता हूं? मान लें कि मेरे पास

import Data.Time.Calendar 

data SchedulePeriod = SchedulePeriod { startDate :: Day 
    , endDate :: Day 
    , accrualStart :: Day 
    , accrualEnd :: Day 
    , resetDate :: Day 
    , paymentDate :: Day 
    , fraction :: Double } 
    deriving (Show) 

और मैं एक बाधा startDate < endDate लागू करना चाहता हूं। क्या कोई सार डेटा प्रकार बनाये बिना ऐसा करने का कोई तरीका है?

Answer 1

मानक तरीका एक smart constructor कि मूल्य बनाने से पहले पूर्व शर्त की जाँच करता है उपयोग करने के लिए, और वास्तविक निर्माता इसे इस्तेमाल करता है निर्यात नहीं कर रहा है। बेशक, यह एक अमूर्त डेटा प्रकार बना रहा है, जैसा आपने कहा था।

एक स्मार्ट निर्माता के बिना इस लक्ष्य को हासिल करने के लिए किया जाएगा एक ही रास्ता वास्तव में बुराई प्रकार प्रणाली hackery (और आप मानक Day प्रकार का उपयोग करने में सक्षम नहीं होगा)।

Answer 2

ईर्ड के जवाब को स्वीकार करें। मैं बस इसे लिख रहा हूं इसलिए मैं एक टिप्पणी में वर्णित स्मार्ट विनाशकों को समझा सकता हूं और मैं एक टिप्पणी में स्पष्टीकरण फिट नहीं कर सकता।

data T x y z = A | B x | C y z 

ehird पहले से ही बताया कि कैसे करने के लिए दूर सार निर्माता, जो सिर्फ है "स्मार्ट" कंस्ट्रक्टर्स प्रदान करने के लिए:

मान लीजिए कि आप प्रकार है कि करते हैं। जैसा आपने बताया है, इसके लिए रचनाकारों को छिपाने की आवश्यकता है और फिर आप उन्हें पैटर्न मिलान में उपयोग नहीं कर सकते हैं। हालांकि, आप इसे "स्मार्ट" विनाशक का उपयोग करके हल कर सकते हैं, जो प्रत्येक संभावित कन्स्ट्रक्टर के खिलाफ पैटर्न-मिलान के बराबर है।

यह समझाने के लिए, का पहला कैसे हम प्रकार टी के एक समारोह लिखते हैं के साथ शुरू करता है, तो कंस्ट्रक्टर्स खुल गए हैं:

myFunction :: T x y z -> d 
myFunction t = case t of 
    A  -> f1 
    B x -> f2 x 
    C y z -> f3 y z 

हम समारोह के प्रकार हस्ताक्षर से पता है कि f1, f2 के प्रकार, और f3 होना चाहिए:

f1 :: d 
f2 :: x -> d 
f3 :: y -> z -> d 

तो अगर हम myFunction सामान्यीकरण करने के लिए एक स्मार्ट नाशक होने के लिए गए थे, हम सिर्फ पारित f1, f2, और +०१२३२६२२०३७इसे करने के लिए के रूप में पैरामीटर:

smartDestructor :: d -> (x -> d) -> (y -> z -> d) -> t -> d 
smartDestructor f1 f2 f3 t = case t of 
    A  -> f1 
    B x -> f2 x 
    C y z -> f3 y z 

तो अगर आप निर्यात smartDestructor, तो लोग कर सकते हैं मूल रूप से निर्माताओं के लिए उपयोग की जरूरत के बिना अपने प्रकार के खिलाफ पैटर्न मैचों की।

क्या तुमने कभी maybe या either कार्यों का उपयोग किया है, इससे पहले कि, तो आप एक स्मार्ट नाशक का उपयोग किया है, हालांकि उन मामलों में कंस्ट्रक्टर्स छिपी नहीं हैं, इसलिए वे मुख्य रूप से सुविधा कार्यों के रूप में प्रदान की जाती हैं:

maybe :: b -> (a -> b) -> Maybe a -> b 
maybe f1 f2 m = case m of 
    Nothing -> f1 
    Just a -> f2 x 

either :: (a -> c) -> (b -> c) -> Either a b -> c 
either f1 f2 e = case e of 
    Left a -> f1 a 
    Right b -> f2 b 

आपके मामले में, स्मार्ट विनाशक का उद्देश्य बस इतना है कि आप रचनाकारों को छुपा सकते हैं और रचनाकारों का पर्दाफाश नहीं कर सकते हैं।