उच्च डेटा

हाँ, हाँ, आपने सपना नहीं देखा और आपने सही सुना - यह एक उच्च प्रकार का है। Kind एक प्रकार का सिद्धांत शब्द है जिसका अनिवार्य रूप से एक प्रकार का प्रकार [डेटा] होता है।

लेकिन पहले, कुछ गीत।

हैबे पर कई लेख प्रकाशित हुए थे, जिसमें कार्यात्मक भाषाओं में डेटा सत्यापन की विधि का विस्तार से वर्णन किया गया था।

यह लेख इस प्रचार में मेरे पाँच सेंट है। हम हास्केल में डेटा सत्यापन पर विचार करेंगे।

सत्यापन लिखें

प्रकार सत्यापन का उपयोग करने वाली एक मान्यता तकनीक का एक उदाहरण पहले माना गया था:

type EmailContactInfo = String type PostalContactInfo = String data ContactInfo = EmailOnly EmailContactInfo | PostOnly PostalContactInfo | EmailAndPost (EmailContactInfo, PostalContactInfo) data Person = Person { pName :: String, , pContactInfo :: ContactInfo, } 

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

उच्च डेटा सत्यापन

इस लेख में, हम उच्च-गुणवत्ता वाले डेटा का उपयोग करते हुए एक अलग सत्यापन विधि को देखेंगे।

मान लें कि हमारे पास एक डेटा प्रकार है:

 data Person = Person { pName :: String , pAge :: Int } 

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

यहां यह संभव है और इसलिए हास्केल में पुस्तकालयों के लेखकों के बीच इस पद्धति का व्यापक रूप से उपयोग किया जाता है।

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

मॉडल का एक तरीका दूसरे डेटा प्रकार का उपयोग करना है:

 data MaybePerson = MaybePerson  { mpName :: Maybe String  , mpAge :: Maybe Int  } 

जहां, मुझे याद है कि वैकल्पिक प्रकार का उपयोग किया जाता है:

 -- already in Prelude data Maybe a = Nothing | Just a 

यहाँ से, सत्यापन कार्य काफी सरल है:

 validate :: MaybePerson -> Maybe Person validate (MaybePerson name age) =  Person <$> name <*> age 

हमारा सत्यापन काम करता है, लेकिन हाथ से अतिरिक्त रूटीन कोड लिखना कष्टप्रद है, क्योंकि यह पूरी तरह से यांत्रिक रूप से किया जाता है। इसके अलावा, इन प्रयासों के दोहराव का मतलब है कि हमें भविष्य में अपने दिमाग का उपयोग करने की आवश्यकता होगी ताकि यह सुनिश्चित हो सके कि तीनों परिभाषाएं सिंक में रहें। अगर यह संकलक इसे संभाल सकता है तो यह बहुत अच्छा होगा?

हैरानी में डालें! वह कर सकते हैं! एक लंबा परिवार हमारी मदद करेगा!

हास्केल में, एक जीनस के रूप में एक ऐसी चीज है, यह एक प्रकार है , और सबसे सरल और सबसे सटीक स्पष्टीकरण यह है कि एक जीनस एक प्रकार का प्रकार [डेटा] है। सबसे व्यापक रूप से इस्तेमाल किया जाने वाला जीनस * है , जिसे "अंतिम" कहा जा सकता है

 ghci> :k Int Int :: * ghci> :k String String :: * ghci> :k Maybe Int Maybe Int :: * ghci> :k Maybe String Maybe String :: * ghci> :k [Int] [Int] :: * 

और शायद किस तरह का?

 ghci> :k Maybe Maybe :: * -> * ghci> :k [] [] :: * -> * 

यह एक उच्च प्रकार का एक उदाहरण है।

ध्यान दें कि हम निम्नलिखित एकल, उच्च श्रेणी के डेटा के साथ व्यक्ति और हो सकता है, दोनों का वर्णन कर सकते हैं:

 data Person' f = Person { pName :: f String , pAge :: f Int } 

यहाँ हम कुछ ' f (लिंग * -> * ) के साथ व्यक्ति को मानकीकृत करते हैं, जो हमें मूल प्रकार का उपयोग करने के लिए निम्नलिखित करने की अनुमति देता है:

 type Person = Person' Identity type MaybePerson = Person' Maybe 

यहां हम एक साधारण आवरण प्रकार की पहचान का उपयोग करते हैं

 -- already in Prelude newtype Identity a = Identity { runIdentity :: a } 

हालांकि यह काम करता है, यह व्यक्ति के मामले में थोड़ा परेशान है, क्योंकि अब हमारा सारा डेटा आइडेंटिटी के अंदर लपेट दिया गया है:

 ghci> :t pName @Identity pName :: Person -> Identity String ghci> :t runIdentity. pName runIdentity. pName :: Person -> String 

हम इस झुंझलाहट को तुच्छता से समाप्त कर सकते हैं, जिसके बाद हम जांच करेंगे कि व्यक्ति की ऐसी परिभाषा ' वास्तव में उपयोगी क्यों है। पहचानकर्ताओं से छुटकारा पाने के लिए, हम एक प्रकार के परिवार (प्रकार स्तर पर एक फ़ंक्शन) का उपयोग कर सकते हैं जो उन्हें मिटा देता है:

 {-# LANGUAGE TypeFamilies #-} -- "Higher-Kinded Data" type family HKD fa where HKD Identity a = a HKD fa = fa data Person' f = Person  { pName :: HKD f String  , pAge :: HKD f Int  } deriving (Generic) 

हमें लेख के दूसरे भाग के लिए जेनेरिक आउटपुट की आवश्यकता है।

HKD प्रकार के परिवार का उपयोग करने का अर्थ है कि GHC हमारे विचारों में किसी भी पहचानकर्ता को मिटा देता है:

 ghci> :t pName @Identity pName :: Person -> String ghci> :t pName @Maybe pName :: Person -> Maybe String 

और यह वास्तव में उच्चतम प्रकार के व्यक्ति का यह संस्करण है जिसे हमारे मूल एक के प्रतिस्थापन के लिए प्रतिस्थापन के रूप में सबसे अच्छे तरीके से उपयोग किया जा सकता है।

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

अब हम अपनी नई तकनीक का उपयोग करके इसे फिर से लिख सकते हैं:

 validate :: Person' Maybe -> Maybe Person validate (Person name age) = Person <$> name <*> age 

बहुत दिलचस्प बदलाव नहीं? लेकिन साज़िश है कि कैसे थोड़ा कम करने की जरूरत है। जैसा कि आप देख सकते हैं, केवल हमारे प्रकार और पैटर्न हमारे प्रारंभिक कार्यान्वयन से मेल खाते हैं। यहां जो साफ-सुथरा है, वह यह है कि हमने अब एक ही दृष्टिकोण में व्यक्ति और हो सकता है कि पीटरसन को समेकित कर दिया है, और इसलिए वे अब केवल सांकेतिक अर्थों में जुड़े नहीं हैं।

जेनरिक और अधिक सामान्य सत्यापन फ़ंक्शन

सत्यापन फ़ंक्शन के वर्तमान संस्करण को प्रत्येक नए डेटा प्रकार के लिए लिखा जाना चाहिए, भले ही कोड काफी नियमित हो।

हम एक सत्यापन संस्करण लिख सकते हैं जो किसी भी उच्च डेटा प्रकार के लिए काम करेगा।

एक टेम्पलेट हास्केल का उपयोग कर सकता है, लेकिन यह कोड उत्पन्न करता है और केवल चरम मामलों में उपयोग किया जाता है। हम नहीं करेंगे।

गुप्त GHC.Generics से संपर्क करना है । यदि आप लाइब्रेरी से अपरिचित हैं, तो यह हास्केल नियमित डेटा प्रकार से एक सामान्य प्रतिनिधित्व को एक समरूपता प्रदान करता है, जिसे स्मार्ट प्रोग्रामर द्वारा संरचनात्मक रूप से नियंत्रित किया जा सकता है (अर्थात: हमें।) कोड प्रदान करके ताकि हम अन्य प्रकार, कार्य और कॉप्टर को बदल सकें। GHC हमारे लिए एक प्रकार का स्वतंत्र कोड लिखता है। यह एक बहुत साफ तकनीक है जो आपके पैर की उंगलियों को गुदगुदी करेगी यदि आपने इसे पहले नहीं देखा है।

अंत में, हम कुछ ऐसा प्राप्त करना चाहते हैं:

 validate :: _ => d Maybe -> Maybe (d Identity) 

जेनरिक के दृष्टिकोण से , किसी भी प्रकार को आमतौर पर कई डिज़ाइनों में विभाजित किया जा सकता है:

 -- undefined data, lifted version of Empty data V1 p -- Unit: used for constructors without arguments, lifted version of () data U1 p = U1 -- a container for ac, Constants, additional parameters and recursion of kind * newtype K1 icp = K1 { unK1 :: c } -- a wrapper, Meta-information (constructor names, etc.) newtype M1 itfp = M1 { unM1 :: fp } -- Sums: encode choice between constructors, lifted version of Either data (:+:) fgp = L1 (fp) | R1 (gp) -- Products: encode multiple arguments to constructors, lifted version of (,) data (:*:) fgp = (fp) :*: (gp) 

अर्थात्, गैर-आरंभिक संरचनाएं, तर्क-मुक्त संरचनाएं, निरंतर संरचनाएं, मेटा-सूचनात्मक (निर्माणकर्ता, आदि) मौजूद हो सकती हैं। और संरचनाओं के संघों - प्रकार के कुल या संगठन OR-OR और एनिमेटेड, वे भी लघु-रूप संघ या रिकॉर्ड हैं।

सबसे पहले, हमें एक वर्ग को परिभाषित करने की आवश्यकता है जो हमारे परिवर्तन का कार्यक्षेत्र होगा। अनुभव से, यह हमेशा सबसे कठिन हिस्सा होता है - इन सामान्यीकृत परिवर्तनों के प्रकार बेहद सार होते हैं और, मेरी राय में, इसके बारे में तर्क करना बहुत मुश्किल है। चलो उपयोग करें:

 {-# LANGUAGE MultiParamTypeClasses #-} class GValidate io where gvalidate :: ip -> Maybe (op) 

आप अपने वर्ग प्रकार को कैसे देखना चाहिए, इस बारे में तर्क करने के लिए आप "नरम और धीमे" नियमों का उपयोग कर सकते हैं, लेकिन सामान्य तौर पर, आपको इनपुट और आउटपुट पैरामीटर दोनों की आवश्यकता होगी। उन दोनों को जीनस * -> * का होना चाहिए, और फिर इस अस्तित्वहीन पी को संचारित करना, अंधेरे, अपवित्र कारणों से मानव जाति के लिए ज्ञात नहीं होना। फिर, एक छोटी चेकलिस्ट का उपयोग करते हुए, हम इस भयानक नारकीय परिदृश्य के चारों ओर हमारे सिर को लपेटने में मदद करने के लिए जाते हैं, जिसे हम बाद में अनुक्रम में चारों ओर जाएंगे।

किसी भी स्थिति में, हमारी कक्षा पहले से ही हमारे हाथों में है, अब हमें विभिन्न प्रकार के GHC.Generic के लिए अपनी कक्षा के उदाहरणों को लिखना होगा। हम आधार मामले से शुरू कर सकते हैं, जिसे हमें सत्यापित करने में सक्षम होना चाहिए, अर्थात् शायद k :

 {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE TypeOperators #-} instance GValidate (K1 a (Maybe k)) (K1 ak) where -- gvalidate :: K1 a (Maybe k) -> Maybe (K1 ak) gvalidate (K1 k) = K1 <$> k {-# INLINE gvalidate #-} 

K1 एक "निरंतर प्रकार" है, जिसका अर्थ है कि यह वह जगह है जहां हमारी संरचनात्मक पुनरावृत्ति समाप्त होती है। हमारे व्यक्ति 'के साथ उदाहरण में , यह pName :: HKD f String होगा ।

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

हम गुणात्मक संरचनाओं के साथ शुरू कर सकते हैं - अगर हमारे पास GValidate io और GValidate i 'o' हैं , तो हमें उन्हें समानांतर में चलाने में सक्षम होना चाहिए:

 instance (GValidate io, GValidate i' o') => GValidate (i :*: i') (o :*: o') where gvalidate (l :*: r) = (:*:) <$> gvalidate l <*> gvalidate r {-# INLINE gvalidate #-} 

यदि K1 हमारे व्यक्ति चयनकर्ताओं को सीधे संदर्भित करता है, (: *: :) लगभग अल्पविराम के सिंटैक्स से मेल खाता है, जिसे हम रिकॉर्ड में अपने क्षेत्रों से अलग करते हैं।

हम प्रतिरूप या सारांश संरचनाओं के लिए एक समान GValidate उदाहरण को परिभाषित कर सकते हैं (डेटा परिभाषा में संबंधित मान अलग हो गए हैं)

 instance (GValidate io, GValidate i' o') => GValidate (i :+: i') (o :+: o') where gvalidate (L1 l) = L1 <$> gvalidate l gvalidate (R1 r) = R1 <$> gvalidate r {-# INLINE gvalidate #-} 

इसके अलावा, जब से हम मेटाडेटा खोजने के बारे में परवाह नहीं करते हैं, हम बस मेटाडेटा निर्माता पर GValidate io को परिभाषित कर सकते हैं:

 instance GValidate io => GValidate (M1 _a _b i) (M1 _a' _b' o) where gvalidate (M1 x) = M1 <$> gvalidate x {-# INLINE gvalidate #-} 

अब हम पूर्ण विवरण के लिए निर्बाध संरचनाओं से बचे हैं। हम उन्हें गैर-आवासीय प्रकार ( V1 ) और बिना किसी पैरामीटर ( U1 ) के डिजाइनरों के लिए निम्नलिखित तुच्छ उदाहरण प्रदान करेंगे:

 instance GValidate V1 V1 where gvalidate = undefined {-# INLINE gvalidate #-} instance GValidate U1 U1 where gvalidate U1 = Just U1 {-# INLINE gvalidate #-} 

अपरिभाषित का उपयोग करना यहां सुरक्षित है, क्योंकि इसे केवल वी 1 के मूल्य के साथ कहा जा सकता है। सौभाग्य से हमारे लिए, V1 निर्जन और निर्जन है, इसलिए यह कभी नहीं हो सकता है, जिसका अर्थ है कि हम अपरिभाषित के हमारे उपयोग में नैतिक रूप से सही हैं।

आगे की हलचल के बिना, अब हमारे पास यह पूरा तंत्र है, हम अंततः सत्यापन का एक गैर-सामान्य संस्करण लिख सकते हैं:

 {-# LANGUAGE FlexibleContexts #-} validate :: ( Generic (f Maybe) , Generic (f Identity) , GValidate (Rep (f Maybe)) (Rep (f Identity)) ) => f Maybe -> Maybe (f Identity) validate = fmap to . gvalidate . from 

हर बार जब आप फ़ंक्शन के लिए हस्ताक्षर वास्तविक कार्यान्वयन की तुलना में लंबे होते हैं, तो आप एक विस्तृत मुस्कान प्राप्त कर सकते हैं; इसका मतलब है कि हमने अपने लिए कोड लिखने के लिए एक कंपाइलर को काम पर रखा है। सत्यापन के लिए यहां जो महत्वपूर्ण है वह यह है कि इसमें व्यक्ति का उल्लेख नहीं है ' ; यह फ़ंक्शन उच्च गुणवत्ता वाले डेटा के रूप में परिभाषित किसी भी प्रकार के लिए काम करेगा। देखा!

परिणाम

आज के दोस्तों के लिए बस इतना ही। हम उच्च-गुणवत्ता वाले डेटा के विचार से परिचित हुए, उन्होंने देखा कि कैसे यह पूरी तरह से अधिक पारंपरिक तरीके से परिभाषित डेटा प्रकार के बराबर है, और इस दृष्टिकोण के साथ क्या चीजें संभव हैं, इसकी एक झलक भी पकड़ी।

यह आपको सभी प्रकार की आश्चर्यजनक चीजें करने की अनुमति देता है, जैसे: टेम्पलेट हास्केल का सहारा लिए बिना मनमाने डेटा प्रकारों के लिए लेंस उत्पन्न करना; डेटा प्रकार द्वारा अनुक्रम ; और स्वचालित रूप से रिकॉर्ड फ़ील्ड का उपयोग करने के लिए निर्भरता को ट्रैक करता है।

उच्च प्रसव के खुश आवेदन!

मूल: उच्च-किन्ड डेटा