एफ # 6: ट्यूपल

तो, F # की हमारी यात्रा जारी है। निम्नलिखित लेख F # प्रकारों पर ध्यान केंद्रित करेगा जो मानक .NET समकक्ष हो सकते हैं या नहीं हो सकते हैं। यह पोस्ट टुपल्स के बारे में है।

ट्यूपल्स क्या हैं

एक टपल अनाम का एक समूह है, लेकिन विभिन्न प्रकारों के संभवतः मूल्यों का आदेश दिया गया है।

टुपल्स बनाना

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

let a = (1,2) let b = (1,"cat") let c = (1,"cat") let d = (1,"cat", 'c') 

यूनिवर्सल ट्यूपल

कार्य जो ट्यूपल्स को स्वीकार करते हैं, वे भी बिना किसी समस्या के सार्वभौमिक ट्यूपल स्वीकार कर सकते हैं। एफ # जैसी एक इंफ़ेक्शन प्रणाली ख़ुशी से टुपल के लिए सही प्रकारों के इंसुलेशन को संभाल लेगी। यहाँ एक उदाहरण है।

 let someFunction tup = let (x,y) = tup printfn "x is %A and y is %A" xy do someFunction ("cat","dog") do someFunction (11,12) 

और यहां निष्पादन के परिणाम ऊपर दिए गए हैं, जहां आप देख सकते हैं कि someFunction फ़ंक्शन ने समस्याओं के बिना विभिन्न टाइप किए गए टुपल्स के साथ स्वीकार किया और काम किया।

टपल हस्ताक्षर

अब तक, हमने F # हस्ताक्षरों की समझ को बिल्कुल भी नहीं छुआ है, वास्तव में यह एक ऐसा विषय है, जिसके बारे में मैंने एक पूरी ब्लॉग पोस्ट समर्पित करने का निर्णय लिया है, क्योंकि मेरा मानना ​​है कि यह काफी जटिल है। हालाँकि, हम उस स्थान पर स्थित हैं जहाँ हम हैं, अर्थात् यहाँ और अभी, और हम tuples का अध्ययन कर रहे हैं, इसलिए अब मैं केवल यह प्रदर्शित करना चाहता था कि tuple का हस्ताक्षर कैसा दिखेगा।

मान लीजिए कि मैंने FSI विंडो में निम्नलिखित ट्यूपल्स घोषित किए हैं:

 let a = (1,2) let b = (1,"codfather") let c = (1,"c", 12.5) 

और फिर मैंने एफएसआई विंडो में उनकी जांच की; हम कुछ इस तरह देखेंगे:

 val a : int * int = (1, 2) val b : int * string = (1, "codfather") val c : int * string * float = (1, "c", 12.5) 

यह दिलचस्प है, हम यहां कुछ चीजों को देख सकते हैं, अर्थात्:

• कोष्ठक एक प्रकार के हस्ताक्षर का हिस्सा नहीं हैं
• एफ # प्रकार प्रणाली टपल में निहित मूल्यों के आधार पर एक प्रकार का सही ढंग से अनुमान लगा सकती है।
• अल्पविराम को "*" से बदल दिया जाता है

तो क्रिस्टल स्पष्ट टपल इस तरह दिखता है:

 let a = (1,2) 

निम्नलिखित हस्ताक्षर होंगे:

 int * int 

टपल टूटना

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

 let (a,b) = (1,2) printfn "(a,b) = (1,2), so value of 'a' should be 1, and it is =%i,\r\n 'b' should be 2, and it is =%i" ab //   ,  ,     ,   //     let (_,z) = (1,2) printfn "grabbing last value from (1,2) which is = %i" z let (a,b :string) = (1,"cat") printfn "grabbing (1,\"cat\") which has values = %i %s" ab let (a :int,b :string) = (1,"cat") printfn "grabbing (1,\"cat\") which has values = %i %s" ab let (a ,b, c) = (1,"cat", 'c') printfn "grabbing (1,\"cat\",'c') which has values = %i %s %c" abc let first = fst (1, 2) printfn "grabbing fst from (1,2) which has values = %i" first let second = snd (1, 2) printfn "grabbing 2nd from (1,2) which has values = %i" second 

परिणाम निम्नानुसार एक मानक कंसोल विंडो में मुद्रित होते हैं:

का उपयोग करते हुए

लेकिन हमें अलग-अलग हिस्से कैसे मिले? ठीक है, आपको केवल उपरोक्त कोड की आवश्यकता है, लेकिन एक उदाहरण देखें। मान लीजिए कि हमारे पास इस तरह से एक नल था:

 (1,2) 

और मैं कुछ नए व्यक्तिगत मूल्यों से बंधे हुए टपल के दोनों "मूल्यों" को प्राप्त करना चाहता था, हम बस यही कर सकते थे:

 let (a,b) = (1,2) 

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

 let (_,z) = (1,2) 

अंतर्निहित ट्यूपल कार्यों का उपयोग करना

एक ट्यूपल से पहला और दूसरा मान प्राप्त करने के लिए अंतर्निहित समर्थन भी है। " Fst " और " snd " फ़ंक्शन का उपयोग करके क्या किया जा सकता है। दूसरे तत्व के अलावा किसी भी चीज के लिए कोई समर्थन नहीं है (ये संभवतः सबसे सामान्य मामले हैं)। " Fst " और " snd " का उपयोग इस प्रकार किया जा सकता है:

 let first = fst (1, 2) let second = snd (1, 2) 

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

 let (a ,b) = (1,"cat", 'c') 

आप देख सकते हैं कि tuple में वास्तव में 3 मान हैं, लेकिन Let बाइंडिंग में केवल 2 मान हैं, इसलिए संकलक हमें इस बारे में चेतावनी देता है, जैसा कि आप नीचे स्क्रीनशॉट में देख सकते हैं:

नई नलियाँ बनाना

आप मौजूदा tuples से नए tuples बनाना चाहते हैं, यह काफी सरल है, यहाँ एक उदाहरण है:

 let oldOne = (1,2) let (x,y) = oldOne let newOne = (x+1,y+1) printfn "original = %A, and we did this (x+1,y+1)\r\n to obtain newOne = %A" oldOne newOne 

टुपल्स की तुलना

टुपल्स को समान माना जाता है यदि

• उनके पास समान मान हैं।
• सभी मूल्यों को समान माना जाता है (जाहिर है, ये कस्टम समान तरीके या कस्टम IEquitable कार्यान्वयन और इस तरह हो सकते हैं)

आइए कुछ सरल उदाहरण देखें।

 printfn "(1,2) = (3,4) =% b" ((1,2) = (3,4)) printfn "(1,2) = (1,2) =% b" ((1,2) = (1,2)) printfn "('a', 'b') = ('a', 'b') =% b" (('a', 'b') = ('a', 'b')) printfn "('a', 'b') = ('a', 'c') =% b" (('a', 'b') = ('a', 'c')) 

वास्तव में, यदि आपके ट्यूपल्स की लंबाई (तत्वों की संख्या) है और आप समानता ऑपरेटर "=" का उपयोग करके उनकी तुलना करने की कोशिश करते हैं, तो आपको एक चेतावनी मिलेगी:

टपल मिलान पैटर्न

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

 let someFunction tup = match tup with | 1,2 -> printfn "you passed (1,2)" | _,_ -> printfn "you passed some other tuple" do someFunction (11,12) do someFunction (4,5) do someFunction (1,2) do someFunction (13,23)