ओपेक टाइप में

ओपेक टाइप के बारे में

परिचय

ओपेक टाइप Elm में एनकैप्सुलेशन की एक तकनीक है। कुछ लोग इसे सूचना छिपाना या इम्प्लीमेंटेशन के विवरण छिपाना भी कहते हैं। इनका उपयोग आम तौर पर पार्स कीजिए, वैलिडेट न करें पैटर्न की मदद से वैलिडेशन लागू करने के लिए भी किया जाता है। उदाहरण के लिए, आपके पास EmailAddress नाम का एक ओपेक टाइप हो सकता है, जिसमें सिर्फ मान्य ईमेल पते ही रखे जा सकते हैं। इसके उलट, एक String में कुछ भी रह सकता है।

ओपेक टाइप बनाना

कस्टम टाइप में एक या एक से अधिक वेरिएंट होते हैं, और कंपाइलर हर वेरिएंट को बनाने के लिए अपने आप एक फंक्शन बना देता है, और इसके लिए वेरिएंट के नाम का इस्तेमाल करता है। कस्टम टाइप बनाने का यही एकमात्र तरीका है। कंपाइलर इन वेरिएंट के लिए डिस्ट्रक्चरिंग की भी सुविधा देता है।

type Maybe a
    = Nothing --> Variant implies a 'Nothing' function, with type 'Maybe a', and destructuring of 'Nothing'
    | Just a  --> Variant implies a 'Just' function, with type 'a -> Maybe a', and destructuring of 'Just _'

डिफ़ॉल्ट रूप से यह सब फाइल या मॉड्यूल के अंदर ही रहता है, और क्या एक्सपोर्ट करना है, यह चुनने के लिए हम exposing कीवर्ड का इस्तेमाल करते हैं। Maybe मॉड्यूल Maybe टाइप को एक्सपोज़ करता है (ताकि दूसरे मॉड्यूल मौजूदा Maybe वैल्यू का इस्तेमाल कर सकें), और साथ ही Nothing तथा Just वेरिएंट भी एक्सपोज़ करता है (ताकि दूसरे मॉड्यूल Maybe वैल्यू बना और डिस्ट्रक्चर कर सकें)। इसके लिए यह इस सिंटैक्स का इस्तेमाल करता है। Maybe(..) वाला हिस्सा Elm को बताता है कि सारे वेरिएंट एक्सपोज़ करें, साथ ही कस्टम टाइप की परिभाषा भी।

module Maybe exposing
  ( Maybe(..)
  -- ...
  )

ओपेक टाइप बनाने के लिए आप बस वेरिएंट एक्सपोर्ट करना बंद कर देते हैं। Maybe टाइप के लिए ऐसा करने पर आप यह सिंटैक्स इस्तेमाल करेंगे:

module Maybe exposing
  ( Maybe
  -- ...
  )

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

पार्स कीजिए, वैलिडेट न करें

ओपेक टाइप का सबसे आम उपयोग शायद पार्स कीजिए, वैलिडेट न करें पैटर्न की मदद से वैलिडेशन लागू करना है। इस पैटर्न में आप एक फंक्शन एक्सपोज़ करते हैं, जो ऐसा इनपुट लेता है जिसमें संरचना या टाइप सेफ्टी उतनी नहीं होती जितनी आप चाहते हैं, जैसे कोई String। फिर यह इस इनपुट को पार्स करके ज़्यादा संरचित टाइप बनाता है, जैसे EmailAddress। नतीजा यह होता है कि यह या तो वह टाइप लौटाता है, या एक एरर (आम तौर पर Maybe या Result)।

उदाहरण के लिए, नीचे दिए कोड में बाहरी मॉड्यूल EmailAddress टाइप सिर्फ parseEmailAddress फंक्शन से ही बना सकते हैं। इसलिए जब आप EmailAddress टाइप पर काम करते हैं, तो आप निश्चित हो सकते हैं कि वह मान्य है।

module EmailAddress exposing ( EmailAddress, parseEmailAddress, getEmailAddress )

-- The `EmailAddress` custom type has one variant, also called `EmailAddress`
-- When a custom type has one variant, it is idiomatic to use the same name for both.
type EmailAddress = 
  EmailAddress String

-- create an EmailAddress variant
parseEmailAddress: String -> Maybe EmailAddress
parseEmailAddress candidateEmailAddress =   
  if isValidEmailAddress candidateEmailAddress then
    Just (EmailAddress candidateEmailAddress)
  else
    Nothing

-- get an EmailAddress variant
getEmailAddress: EmailAddress -> String
getEmailAddress ( EmailAddress  emailAdress ) =
  emailAdress

isValidEmailAddress: String -> bool
-- ...