बुनियादी प्रकारों में एक छोटे से विषयांतर के बाद, हम फिर से कार्य पर लौट सकते हैं। विशेष रूप से, पहले उल्लेख की गई पहेली के लिए: यदि कोई गणितीय फ़ंक्शन केवल एक पैरामीटर ले सकता है, तो F # में एक फ़ंक्शन अधिक पैरामीटर कैसे ले सकता है? कटौती के तहत अधिक जानकारी!

इसका उत्तर काफी सरल है: कई मापदंडों के साथ एक फ़ंक्शन नए कार्यों की एक श्रृंखला के रूप में फिर से लिखा जाता है, जिनमें से प्रत्येक केवल एक पैरामीटर लेता है। संकलक इस ऑपरेशन को स्वचालित रूप से करता है, और इसे " करी " कहा जाता है, हास्केल करी के सम्मान में, एक गणितज्ञ, जिसने कार्यात्मक प्रोग्रामिंग के विकास को काफी प्रभावित किया।

यह देखने के लिए कि अभ्यास में करी कैसे काम करती है, आइए एक सरल कोड उदाहरण का उपयोग करें जो दो संख्याओं को प्रिंट करता है:

//   let printTwoParameters xy = printfn "x=%iy=%i" xy

वास्तव में, कंपाइलर इसे लगभग निम्नलिखित रूप में लिखते हैं:

 //    let printTwoParameters x = //    let subFunction y = printfn "x=%iy=%i" xy //  ,    subFunction //

इस प्रक्रिया पर अधिक विस्तार से विचार करें:

" printTwoParameters " नाम के साथ एक फ़ंक्शन printTwoParameters , लेकिन केवल एक पैरामीटर को स्वीकार करते हुए: "x"।
इसके अंदर एक स्थानीय फ़ंक्शन बनाया जाता है, जो केवल एक पैरामीटर लेता है: "y"। ध्यान दें कि स्थानीय फ़ंक्शन पैरामीटर "x" का उपयोग करता है, लेकिन x को तर्क के रूप में इसे पारित नहीं किया जाता है। "x" इस तरह के दायरे में है कि एक नेस्टेड फ़ंक्शन इसे देख सकता है और इसे पारित करने की आवश्यकता के बिना इसका उपयोग कर सकता है।
अंत में, नया बनाया गया स्थानीय फ़ंक्शन वापस आ जाता है।
लौटाया गया फ़ंक्शन फिर "y" तर्क पर लागू होता है। पैरामीटर "x" इसमें बंद है ताकि लौटे फ़ंक्शन को अपना तर्क पूरा करने के लिए केवल पैरामीटर "y" की आवश्यकता हो।

इस तरह से कार्यों को फिर से लिखना, संकलक सुनिश्चित करता है कि प्रत्येक फ़ंक्शन केवल एक पैरामीटर को स्वीकार करता है, आवश्यकतानुसार। इस प्रकार, " printTwoParameters " का उपयोग करते हुए, आप सोच सकते हैं कि यह दो मापदंडों के साथ एक फ़ंक्शन है, लेकिन वास्तव में केवल एक पैरामीटर के साथ एक फ़ंक्शन का उपयोग किया जाता है। आप इसे दो के बजाय केवल एक तर्क से सत्यापित कर सकते हैं:

 //     printTwoParameters 1 //    val it : (int -> unit) = <fun:printTwoParameters@286-3>

यदि हम इसे एक तर्क के साथ गणना करते हैं, तो हमें कोई त्रुटि नहीं मिलेगी - फ़ंक्शन वापस कर दिया जाएगा।

तो, यहाँ वास्तव में क्या होता है जब printTwoParameters को दो तर्कों के साथ कहा जाता है:

printTwoParameters को पहले तर्क (x) के साथ printTwoParameters
printTwoParameters एक नया फ़ंक्शन देता है जिसमें "x" बंद है।
फिर दूसरे तर्क (y) के साथ एक नया फ़ंक्शन कहा जाता है

यहाँ चरण-दर-चरण और सामान्य संस्करणों का एक उदाहरण दिया गया है:

 //   let x = 6 let y = 99 let intermediateFn = printTwoParameters x //  -  // x   let result = intermediateFn y //     let result = (printTwoParameters x) y //   let result = printTwoParameters xy

यहाँ एक और उदाहरण है:

 //  let addTwoParameters xy = x + y //   let addTwoParameters x = //   ! let subFunction y = x + y //      subFunction //   //       let x = 6 let y = 99 let intermediateFn = addTwoParameters x //  -  // x   let result = intermediateFn y //   let result = addTwoParameters xy

फिर, एक "दो मापदंडों के साथ कार्य" वास्तव में एक पैरामीटर के साथ एक फ़ंक्शन है, जो एक मध्यवर्ती फ़ंक्शन देता है।

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

जब हम एक्सप्रेशन x+y लिखते हैं, तो कंपाइलर कोड को इस तरह से रीक्रिएट करता है जैसे कि infix को (+) xy कन्वर्ट करता है, जो कि एक फंक्शन है जिसका नाम है + जो दो पैरामीटर लेता है। ध्यान दें कि "+" फ़ंक्शन को यह इंगित करने के लिए कोष्ठक की आवश्यकता है कि इसका उपयोग एक नियमित फ़ंक्शन के रूप में किया जाता है, न कि एक infix ऑपरेटर के रूप में।

अंत में, दो मापदंडों वाला एक फ़ंक्शन, जिसे + कहा जाता है, को दो मापदंडों के साथ किसी भी अन्य फ़ंक्शन की तरह माना जाता है।

 //         let x = 6 let y = 99 let intermediateFn = (+) x //   ""  ""   let result = intermediateFn y //        let result = (+) xy //       let result = x + y

और हां, यह अन्य सभी ऑपरेटरों के लिए काम करता है और printf जैसे अंतर्निहित कार्य करता है।

 //    let result = 3 * 5 //    - let intermediateFn = (*) 3 //  ""  3   let result = intermediateFn 5 //    printfn let result = printfn "x=%iy=%i" 3 5 // printfn   - let intermediateFn = printfn "x=%iy=%i" 3 // "3"   let result = intermediateFn 5

करी फंक्शन हस्ताक्षर

अब जब हम जानते हैं कि कैसे कार्य करता है, तो यह जानना दिलचस्प है कि उनके हस्ताक्षर क्या दिखेंगे।

पहले उदाहरण पर लौटते हुए, " printTwoParameter ", हमने देखा कि फ़ंक्शन ने एक तर्क लिया और एक मध्यवर्ती फ़ंक्शन लौटाया। मध्यवर्ती फ़ंक्शन ने भी एक तर्क लिया और कुछ भी नहीं लौटाया (अर्थात unit )। इसलिए, मध्यवर्ती कार्य प्रकार int->unit । दूसरे शब्दों में, डोमेन printTwoParameters int , और रेंज int->unit । इसे एक साथ रखकर हम अंतिम हस्ताक्षर देखेंगे:

 val printTwoParameters : int -> (int -> unit)

यदि आप स्पष्ट रूप से करी गई कार्यान्वयन की गणना करते हैं, तो आप हस्ताक्षर में कोष्ठक देख सकते हैं, लेकिन यदि आप एक साधारण, स्पष्ट रूप से करी गई कार्यान्वयन की गणना करते हैं, तो कोई ब्रैकेट नहीं होगा:

 val printTwoParameters : int -> int -> unit

ब्रैकेट वैकल्पिक हैं। लेकिन फ़ंक्शन हस्ताक्षरों की धारणा को सरल बनाने के लिए उन्हें दिमाग में प्रस्तुत किया जा सकता है।

और एक फ़ंक्शन के बीच अंतर क्या है जो दो मापदंडों के साथ एक मध्यवर्ती फ़ंक्शन और एक नियमित फ़ंक्शन लौटाता है?

यहां एक फ़ंक्शन एक पैरामीटर के साथ है जो एक और फ़ंक्शन देता है:

 let add1Param x = (+) x // signature is = int -> (int -> int)

और यहां दो मानदंड हैं जो एक साधारण मान लौटाता है:

 let add2Params xy = (+) xy // signature is = int -> int -> int

उनके हस्ताक्षर थोड़े अलग हैं, लेकिन व्यावहारिक रूप से उनके बीच बहुत अंतर नहीं है, केवल इस तथ्य को छोड़कर कि दूसरा फ़ंक्शन स्वचालित रूप से करी है।

दो से अधिक मापदंडों के साथ कार्य

दो से अधिक मापदंडों के साथ कार्यों के लिए करीकरण कैसे काम करता है? उसी तरह: प्रत्येक पैरामीटर के लिए, अंतिम को छोड़कर, फ़ंक्शन एक मध्यवर्ती फ़ंक्शन देता है जो पिछले पैरामीटर को बंद कर देता है।

इस कठिन उदाहरण पर विचार करें। मैंने स्पष्ट रूप से पैरामीटर प्रकार घोषित किए हैं, लेकिन फ़ंक्शन कुछ भी नहीं करता है।

 let multiParamFn (p1:int)(p2:bool)(p3:string)(p4:float)= () //   let intermediateFn1 = multiParamFn 42 // multoParamFn  int   (bool -> string -> float -> unit) // intermediateFn1  bool //   (string -> float -> unit) let intermediateFn2 = intermediateFn1 false // intermediateFn2  string //   (float -> unit) let intermediateFn3 = intermediateFn2 "hello" // intermediateFn3 float //     (unit) let finalResult = intermediateFn3 3.141

पूरे समारोह के हस्ताक्षर:

 val multiParamFn : int -> bool -> string -> float -> unit

और मध्यवर्ती कार्यों के हस्ताक्षर:

 val intermediateFn1 : (bool -> string -> float -> unit) val intermediateFn2 : (string -> float -> unit) val intermediateFn3 : (float -> unit) val finalResult : unit = ()

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

 int->int->int // 2  int  int string->bool->int //   string,  - bool, //  int int->string->bool->unit //   (int,string,bool) //    (unit) (int->string)->int //   ,  // ( int  string) //   int (int->string)->(int->bool) //   (int  string) //   (int  bool)

एकाधिक पैरामीटर कठिनाइयाँ

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

पहली नज़र में हानिरहित एक समारोह पर विचार करें:

 //   let printHello() = printfn "hello"

आपको क्या लगता है यदि आप इसे नीचे दिखाए गए अनुसार करेंगे तो क्या होगा? कंसोल में "हैलो" प्रिंट होगा? निष्पादन से पहले अनुमान लगाने की कोशिश करें। संकेत: फ़ंक्शन के हस्ताक्षर को देखें।

 //   printHello

उम्मीदों के विपरीत, कोई कॉल नहीं होगा। मूल फ़ंक्शन unit को एक तर्क के रूप में अपेक्षा करता है जिसे पारित नहीं किया गया है। इसलिए, आंशिक रूप से लागू फ़ंक्शन प्राप्त किया गया था (इस मामले में, बिना तर्क के)।

इस मामले का क्या? क्या इसे संकलित किया जाएगा?

 let addXY xy = printfn "x=%iy=%i" x x + y

यदि आप इसे चलाते हैं, तो संकलक printfn साथ लाइन के बारे में शिकायत करेगा।

 printfn "x=%iy=%i" x //^^^^^^^^^^^^^^^^^^^^^ //warning FS0193: This expression is a function value, ie is missing //arguments. Its type is ^a -> unit.

यदि करीने की कोई समझ नहीं है, तो यह संदेश बहुत गूढ़ हो सकता है। तथ्य यह है कि सभी अभिव्यक्तियों का अलग-अलग मूल्यांकन किया जाता है (जो कि रिटर्न वैल्यू के रूप में उपयोग नहीं किया जाता है या "लेट" के माध्यम से किसी चीज से बंधे हैं) का unit मूल्य में मूल्यांकन किया जाना चाहिए । इस मामले में, यह unit मूल्य में गणना नहीं की जाती है, बल्कि एक फ़ंक्शन देता है। यह कहने का एक लंबा तरीका है कि printfn एक तर्क याद कर रहा है।

ज्यादातर मामलों में, .NET दुनिया के किसी पुस्तकालय के साथ बातचीत करते समय इस तरह की त्रुटियां होती हैं। उदाहरण के लिए, TextReader वर्ग की Readline विधि को एक unit पैरामीटर लेना चाहिए। आप अक्सर इस बारे में भूल सकते हैं और कोष्ठक नहीं डाल सकते हैं, इस मामले में आपको "कॉल" के समय एक कंपाइलर त्रुटि नहीं मिल सकती है, लेकिन यह तब दिखाई देगा जब आप परिणाम को स्ट्रिंग के रूप में व्याख्या करने का प्रयास करेंगे।

 let reader = new System.IO.StringReader("hello"); let line1 = reader.ReadLine // ,    printfn "The line is %s" line1 //    // ==> error FS0001: This expression was expected to have // type string but here has type unit -> string let line2 = reader.ReadLine() // printfn "The line is %s" line2 //

उपरोक्त कोड में, line1 केवल एक संकेतक या Readline पद्धति का प्रतिनिधि है, न कि एक स्ट्रिंग, जैसा कि आप उम्मीद कर सकते हैं। reader.ReadLine() में उपयोग () । reader.ReadLine() वास्तव में फ़ंक्शन को कॉल करेगा।

बहुत सारे विकल्प

यदि आप किसी फ़ंक्शन में बहुत सारे पैरामीटर पास करते हैं तो आप समान रूप से गुप्त संदेश प्राप्त कर सकते हैं। printf करने के लिए बहुत सारे मापदंडों को पारित करने के कुछ उदाहरण:

 printfn "hello" 42 // ==> error FS0001: This expression was expected to have // type 'a -> 'b but here has type unit printfn "hello %i" 42 43 // ==> Error FS0001: Type mismatch. Expecting a 'a -> 'b -> 'c // but given a 'a -> unit printfn "hello %i %i" 42 43 44 // ==> Error FS0001: Type mismatch. Expecting a 'a->'b->'c->'d // but given a 'a -> 'b -> unit

उदाहरण के लिए, बाद के मामले में, कंपाइलर रिपोर्ट करता है कि तीन मापदंडों वाला एक प्रारूप स्ट्रिंग अपेक्षित है (हस्ताक्षर 'a -> 'b -> 'c -> 'd में तीन पैरामीटर हैं), लेकिन इसके बजाय, दो के साथ एक स्ट्रिंग प्राप्त होती है (हस्ताक्षर 'a -> 'b -> unit दो पैरामीटर)।

उन मामलों में जहां printf का उपयोग नहीं किया जाता है, बड़ी संख्या में मापदंडों को पारित करने का अर्थ है कि गणना के एक निश्चित चरण में, एक सरल मूल्य प्राप्त किया गया था, जिसके लिए पैरामीटर की कोशिश की जा रही है। संकलक नाराजगी जताएगा कि एक साधारण मूल्य एक फ़ंक्शन नहीं है।

 let add1 x = x + 1 let x = add1 2 3 // ==> error FS0003: This value is not a function // and cannot be applied

यदि हम सामान्य मध्यवर्ती कार्यों की एक श्रृंखला में सामान्य कॉल को तोड़ते हैं, जैसा कि हमने पहले किया था, हम देख सकते हैं कि वास्तव में क्या गलत हो रहा है।

 let add1 x = x + 1 let intermediateFn = add1 2 //   let x = intermediateFn 3 //intermediateFn  ! // ==> error FS0003: This value is not a function // and cannot be applied

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

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

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

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

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

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

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

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

क्रियात्मक सोच। भाग ४