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

• पहला भाग
• दूसरा भाग
• तीसरा भाग
• चौथा भाग
• पाँचवाँ भाग
• छठा भाग
• सातवाँ भाग

स्पष्ट नहीं है, लेकिन एफ # में दो वाक्यविन्यास हैं: नियमित (सार्थक) अभिव्यक्तियों के लिए और प्रकार की परिभाषाओं के लिए। उदाहरण के लिए:

[1;2;3] //   int list //   Some 1 //   int option //   (1,"a") //   int * string //   

प्रकारों के लिए अभिव्यक्तियों में एक विशेष वाक्यविन्यास होता है जो सामान्य अभिव्यक्तियों के वाक्यविन्यास से भिन्न होता है। FSI (FSharp Interactive) के साथ काम करते समय आपने इस वाक्यविन्यास के कई उदाहरण देखे होंगे प्रत्येक अभिव्यक्ति के प्रकार इसके निष्पादन के परिणामों के साथ प्रदर्शित किए जाते हैं।

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

यहाँ प्रकार वाक्यविन्यास हस्ताक्षर के कुछ उदाहरण दिए गए हैं:

 //   //   let add1 x = x + 1 // int -> int let add xy = x + y // int -> int -> int let print x = printf "%A" x // 'a -> unit System.Console.ReadLine // unit -> string List.sum // 'a list -> 'a List.filter // ('a -> bool) -> 'a list -> 'a list List.map // ('a -> 'b) -> 'a list -> 'b list 

हस्ताक्षर के माध्यम से कार्यों को समझना

अक्सर, यहां तक ​​कि किसी फ़ंक्शन के हस्ताक्षर का अध्ययन करके भी, आप कुछ विचार कर सकते हैं कि यह क्या करता है। कुछ उदाहरणों पर विचार करें और बदले में उनका विश्लेषण करें।

 int -> int -> int 

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

 int -> unit 

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

 unit -> string 

यह फ़ंक्शन कुछ भी स्वीकार नहीं करता है, लेकिन एक string लौटाता है, जिसका अर्थ हो सकता है कि फ़ंक्शन हवा से एक स्ट्रिंग प्राप्त करता है। चूंकि कोई स्पष्ट इनपुट नहीं है, इसलिए फ़ंक्शन शायद रीडिंग (किसी फ़ाइल से कहना) या पीढ़ी (यादृच्छिक स्ट्रिंग की तरह) के साथ कुछ करता है।

 int -> (unit -> string) 

यह फ़ंक्शन एक int लेता है और एक अन्य फ़ंक्शन लौटाता है जिसे कॉल करने पर एक स्ट्रिंग वापस आ जाएगी। फिर, शायद, फ़ंक्शन एक रीड या जेनरेशन ऑपरेशन करता है। इनपुट किसी भी तरह से रिटर्न फंक्शन को इनिशियलाइज़ करने की संभावना है। उदाहरण के लिए, इनपुट फ़ाइल का पहचानकर्ता हो सकता है, और लौटाया गया फ़ंक्शन readline() समान है। या, इनपुट एक यादृच्छिक स्ट्रिंग जनरेटर के लिए शुरुआती मूल्य हो सकता है। हम निश्चित रूप से नहीं कह सकते हैं, लेकिन हम कुछ निष्कर्ष निकाल सकते हैं।

 'a list -> 'a 

फ़ंक्शन किसी भी प्रकार की सूची को स्वीकार करता है, लेकिन इस प्रकार का केवल एक मान लौटाता है। यह इंगित कर सकता है कि फ़ंक्शन सूची को एकत्र करता है या इसके तत्वों में से एक का चयन करता है। एक समान हस्ताक्षर List.sum , List.max , List.head , आदि है।

 ('a -> bool) -> 'a list -> 'a list 

यह फ़ंक्शन दो पैरामीटर लेता है: पहला एक फ़ंक्शन है जो किसी चीज़ को bool (विधेय) में परिवर्तित करता है, दूसरा एक सूची है। वापसी मान उसी प्रकार की एक सूची है। यह निर्धारित करने के लिए विधेय का उपयोग किया जाता है कि क्या कोई वस्तु एक निश्चित मानदंड से मिलती है, और क्या यह कार्य किसी सूची से तत्वों का चयन करने के लिए एक विधेय के अनुसार लगता है - सही या गलत। उसके बाद, यह मूल सूची का एक सबसेट लौटाता है। इस हस्ताक्षर के साथ एक फ़ंक्शन का उदाहरण List.filter ।

 ('a -> 'b) -> 'a list -> 'b list 

फ़ंक्शन दो पैरामीटर लेता है: प्रकार से रूपांतरण 'a से टाइप 'b और प्रकार 'a सूची 'a । वापसी मान प्रकार 'b की एक सूची है। यह मान लेना उचित है कि फ़ंक्शन प्रत्येक तत्व को सूची 'a से लेता 'a , और इसे 'b परिवर्तित करता है, पहले पैरामीटर के रूप में पास किए गए फ़ंक्शन का उपयोग करके, और फिर सूची 'b लौटाता है। वास्तव में, List.map इस तरह के हस्ताक्षर के साथ एक फ़ंक्शन का प्रोटोटाइप है।

हस्ताक्षर के साथ पुस्तकालय के तरीकों की खोज करें

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

उदाहरण के लिए, आपके पास दो सूचियाँ हैं, और आप उन्हें एक में मिला कर एक फ़ंक्शन खोजना चाहते हैं। वांछित कार्य पर क्या हस्ताक्षर होंगे? इसे दो सूचियों को मापदंडों के रूप में लेना होगा और एक तिहाई वापस करना होगा, सभी एक ही प्रकार:

 'a list -> 'a list -> 'a list 

अब सूची मॉड्यूल के लिए MSDN प्रलेखन साइट पर जाएं , और एक समान फ़ंक्शन की तलाश करें। यह पता चला है कि इस तरह के हस्ताक्षर के साथ केवल एक ही कार्य है:

 append : 'T list -> 'T list -> 'T list 

आपको क्या चाहिए!

फ़ंक्शन हस्ताक्षरों के लिए देशी प्रकारों को परिभाषित करना

किसी दिन आप इच्छित फ़ंक्शन के लिए अपने स्वयं के प्रकारों को परिभाषित करना चाहेंगे। यह कीवर्ड "प्रकार" का उपयोग करके किया जा सकता है:

 type Adder = int -> int type AdderGenerator = int -> Adder 

भविष्य में, आप फ़ंक्शन मापदंडों के मूल्यों को सीमित करने के लिए इन प्रकारों का उपयोग कर सकते हैं।

उदाहरण के लिए, एक दूसरी घोषणा एक कलाकारों की त्रुटि के साथ प्रतिबंध के कारण गिर जाएगी। यदि हम इसे हटा देते हैं (तीसरी घोषणा के अनुसार), तो त्रुटि गायब हो जाएगी।

 let a:AdderGenerator = fun x -> (fun y -> x + y) let b:AdderGenerator = fun (x:float) -> (fun y -> x + y) let c = fun (x:float) -> (fun y -> x + y) 

फंक्शन हस्ताक्षर को समझना

क्या आप फ़ंक्शन हस्ताक्षरों को अच्छी तरह से समझते हैं? अपने आप को जांचें कि क्या आप नीचे हस्ताक्षर के साथ सरल कार्य बना सकते हैं। स्पष्ट रूप से निर्दिष्ट प्रकारों से बचें!

 val testA = int -> int val testB = int -> int -> int val testC = int -> (int -> int) val testD = (int -> int) -> int val testE = int -> int -> int -> int val testF = (int -> int) -> (int -> int) val testG = int -> (int -> int) -> int val testH = (int -> int -> int) -> int 

अतिरिक्त संसाधन

F # के लिए कई ट्यूटोरियल हैं, जिनमें उन लोगों के लिए सामग्री शामिल है जो C # या Java अनुभव के साथ आते हैं। निम्नलिखित लिंक उपयोगी हो सकते हैं क्योंकि आप F # में गहराई से जाते हैं:

• एफ # गाइड
• मज़ा और लाभ के लिए एफ #
• एफ # विकी
• Y मिनट में जानें X: F #

F # सीखना शुरू करने के कई अन्य तरीके भी वर्णित हैं।

अंत में, एफ # समुदाय बहुत शुरुआती अनुकूल है। स्लैक में एक बहुत सक्रिय चैट है, एफ # सॉफ्टवेयर फाउंडेशन द्वारा समर्थित है, शुरुआती कमरों के साथ जो आप स्वतंत्र रूप से शामिल हो सकते हैं । हम दृढ़ता से अनुशंसा करते हैं कि आप ऐसा करते हैं!

रूसी भाषी समुदाय F # की साइट पर जाना न भूलें! यदि आपके पास भाषा सीखने के बारे में कोई प्रश्न हैं, तो हमें उनसे चैट रूम में चर्चा करने में खुशी होगी:

• एफ # सॉफ्टवेयर फाउंडेशन स्लैक चैट में कमरा # #ru_general
• Telegram में चैट करें
• गटर में चैट करें
• एफ # सॉफ्टवेयर फाउंडेशन स्लैक चैट में कमरा # जेन_नरल

अनुवाद लेखकों के बारे में

@Kleidemos द्वारा अनुवादित
अनुवाद और संपादकीय परिवर्तन एफ # डेवलपर्स के रूसी भाषी समुदाय के प्रयासों द्वारा किए गए थे। हम इस लेख को प्रकाशन के लिए तैयार करने के लिए @schvepsss और @shwars को भी धन्यवाद देते हैं ।