F # 9: टाइप विकल्प

यदि C # में संदर्भ प्रकारों के लिए नल और संरचनाओं के लिए Nullabe की अवधारणा है। यह निम्नलिखित 2 रूपों में से एक ले सकता है (प्रदर्शन के लिए, मैं यहां इंट प्रकार का उपयोग करता हूं, लेकिन प्रकार किसी भी संरचना का हो सकता है)।

• नल
• int?

वे दोनों बराबर हैं।

Nullable class कई सहायक गुण और विधियाँ प्रदान करता है जो अशक्त प्रकार और संरचनाओं के साथ काम करना आसान बनाता है। ये निम्नलिखित हैं:

• HasValue
• मूल्य
• GetValueOrDefault ()
• GetValueOrDefault (T)

विकल्प प्रकार के रूप में एफ # से थोड़ा अलग है, जो कि अधिक एफ # अनुकूल प्रकार है जो शून्य से निपटने के लिए पसंद नहीं करता है, लेकिन "मई प्रकार मान" या "मई नहीं है" के संदर्भ में चीजों से निपटने के लिए पसंद करता है। मान। " यह अशक्त की तरह लगता है, लेकिन अंत में यह एफ # प्रकार है, इसलिए आप इसे सामान्य रूप से एफ # चीजों में उपयोग करने की उम्मीद कर सकते हैं।

विकल्प एफ # प्रकार के साथ ध्यान देने योग्य एक और बात यह है कि इसका उपयोग किसी भी प्रकार के लिए किया जा सकता है, न कि केवल संरचनाओं के लिए। यह .NET Nullable से अलग है, जिसका उपयोग केवल संरचनाओं के साथ किया जा सकता है।

मान का उपयोग तब किया जाता है जब कोई मूल्य नहीं होता है; अन्यथा, कुछ अभिव्यक्ति (...) एक मान प्रदान करता है। मान कुछ और कोई नहीं एक पैटर्न के साथ मिलान करते समय उपयोग किया जा सकता है, जिसका एक उदाहरण हम इस पोस्ट में देखेंगे।

Nullable की तरह, F # Option प्रकार में कई सहायक गुण / विधियाँ होती हैं, जिन्हें नीचे दी गई तालिका में दिखाया गया है।

कोई नहीं
'टी विकल्प
एक स्थिर संपत्ति जो आपको किसी के मान के साथ एक पैरामीटर मान बनाने की अनुमति देती है।
IsNone
bool
अगर पैरामीटर कोई नहीं है, तो यह सच है।
IsSome
bool
यदि पैरामीटर के अलावा कोई भी मान नहीं है, तो यह सही है।
कुछ
'टी विकल्प
एक स्थिर सदस्य जो एक पैरामीटर बनाता है जिसका मूल्य कोई नहीं है।
मूल्य
'टी
आधार मान लौटाता है या यदि कोई नहीं है तो NullReferenceException फेंकता है।

विकल्प बनाना

इसलिए, अब हम जानते हैं कि विकल्प प्रकार क्या हैं, हम उन्हें कैसे बनाते हैं। आइए कुछ उदाहरण देखें। ध्यान दें कि इस उदाहरण में, मैंने सहायक तरीके IsSome / IsNone का उपयोग किया है। व्यक्तिगत रूप से, मेरा मानना ​​है कि नमूने के साथ तुलना करना सबसे अच्छा तरीका है, क्योंकि यह आपको बिना किसी विकल्प सहित सभी मामलों की तुलना करने में मदद करेगा।

वास्तव में, मैं आपको दिखाऊंगा कि जब आप हेल्पर विधियों का उपयोग करने का निर्णय लेते हैं, तो विकल्प प्रकारों के साथ काम करते समय कुछ गलत करना कितना आसान होता है, लेकिन पहले हम सही मामले का एक उदाहरण देखें।

 let someInt = Some(43) let someString = Some("cat") let printTheOption (opt :Option<'a>) = printfn "Actual Option=%A" opt printfn "IsNone=%b, IsSome=%b Value=%A\r\n\r\n" opt.IsNone opt.IsSome opt.Value printfn "let someInt = Some(43)" printfn "let someString = Some(\"cat\")" printfn "printTheOption (someInt)" printTheOption someInt printfn "printTheOption (someString)" printTheOption someString 

लेकिन क्या होगा यदि हम इस कोड का उपयोग करके इसे फिर से आज़माएँ, जहाँ हमारे पास विकल्प मान के लिए कोई नहीं है, जिसे हम PrintTheOption फ़ंक्शन को पास करेंगे:

 let demoNone = None let printTheOption (opt :Option<'a>) = printfn "Actual Option=%A" opt printfn "IsNone=%b, IsSome=%b Value=%A\r\n\r\n" opt.IsNone opt.IsSome opt.Value printfn "let demoNone = None" printfn "printTheOption demoNone" printTheOption demoNone 

जैसा कि आप देख सकते हैं, हमारे यहाँ एक समस्या है। समस्या यह है कि हमने सहायक संपत्ति Option.Value का उपयोग करके विकल्प मान प्राप्त करने की कोशिश की, इस मामले में यह कोई भी नहीं है, इसलिए हमें NullReferenceException मिली। यह ऊपर दी गई तालिका में दिखाया गया है कि जब आप सहायक गुणों और विधियों का उपयोग करते हैं, तो आप एक अपवाद प्राप्त कर सकते हैं। ठीक है, आप IsNone पद्धति का उपयोग कर सकते हैं और जब आप सिर्फ एक अच्छा साफ पैटर्न मैच का उपयोग कर सकते हैं, तो आप हमेशा इस का उपयोग करके मूल्य की जांच करेंगे।

यदि आप इसे स्वीकार नहीं कर सकते हैं, तो अपने आप से पूछें कि C # का उपयोग करते समय आपको कितनी बार शून्य मान की जांच करनी थी। यहां तक ​​कि लोगों को नियमित रूप से .NET कोड में कार्यात्मक निर्माण, जैसे शायद नल मोनाड, शामिल करने के लिए नेतृत्व किया।

इसलिए, अब जब हमने सहायक विधियों / गुणों का उपयोग करने का खतरा देखा है, तो आइए अब अपना ध्यान दें कि हम इन अपवादों से कैसे बच सकते हैं:

 et printTheOption (opt :Option<'a>) = match opt with | Some a -> printfn "opt is Some, and has value %A" a | None -> printfn "opt is None" let demoNone = None let someInt = Some 1 let someString = Some "crazy dude in the monkey house" printTheOption demoNone printTheOption someInt printTheOption someString 

मेरी निजी राय है कि यह कोड से अधिक पठनीय है जो हर जगह IsSome / IsNone के साथ अंकित किया जाएगा। यह, निश्चित रूप से, हर किसी का व्यवसाय है, लेकिन इस सरल समारोह में हमने यहां सभी मूल बातों को कवर किया है, इस तथ्य को नजरअंदाज नहीं किया जा सकता है।

विकल्प बनाम अशक्त

इसलिए, हमने Nullabe की तुलना में F # में विकल्प के बारे में बात की, और हम जानते हैं कि विकल्प प्रकार का उपयोग किसी भी प्रकार के साथ किया जा सकता है, जबकि Nullable का उपयोग केवल संरचनाओं के साथ किया जा सकता है। लेकिन .NET में नियमित संदर्भ प्रकारों की तुलना में विकल्प प्रकारों के बारे में क्या है। ठीक है, विकल्प के लिए एक बड़ी जीत यह है कि जब आप .NET में संदर्भ प्रकार का उपयोग करते हैं, तो आप एक पॉइंटर संदर्भ के साथ काम कर रहे हैं, जो इस तरह से शून्य पर सेट किया जा सकता है। हालाँकि, ऑब्जेक्ट का प्रकार वही रहता है जैसा कि घोषित किया गया था, जिसमें ढेर (हीप) में ऑब्जेक्ट का एक वैध संदर्भ हो सकता है या अशक्त हो सकता है।

इस तरह लिखना सामान्य होगा:

 string s1 = "cats"; int s1Length = s1.Length; string s2 = null; int s2Length = s2.Length; 

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

यह स्क्रीन शॉट LinqPad का उपयोग करता है, इसलिए यह थोड़ा असामान्य लग सकता है यदि आपने पहले LinqPad नहीं देखा है, लेकिन मेरा विश्वास करो, आपको अभी भी एक अलग IDE में एक ही परिणाम मिलता है।



अब देखते हैं कि F # में समतुल्य कोड कैसे दिखेगा

 let s1 = "Cats" let s1Length = s1.Length; let s2 = None let s2Length = s2.Length; //excplicily string typed None let s3 = Option.None let s3Length = s3.Length; 

इस कोड पर, आपको तत्काल संकलन त्रुटि मिलेगी, क्योंकि s3 को एक अन्य प्रकार माना जाएगा, जिसमें "लंबाई" संपत्ति नहीं है।

विकल्प तुलना

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

तो इस तरह की बात से F # में तत्काल संकलन-समय त्रुटि हो सकती है

 let o1 = Some 1 let o2 = Some "Cats" printfn "o1=o2 : %b" (o1 = o2) 

यह अपेक्षा के अनुरूप काम करेगा क्योंकि प्रकार समान हैं

 let o1 = Some "Cats" let o2 = Some "Cats" let o3 = Some "cats" printfn "o1=o2 : %b" (o1 = o2) printfn "o2=o3 : %b" (o2 = o3)