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

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

कार्यों का आंशिक उपयोग

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

//  ""       +  42 let add42 = (+) 42 //    add42 1 add42 3 //       //      [1;2;3] |> List.map add42 //          "" let twoIsLessThan = (<) 2 //   twoIsLessThan 1 twoIsLessThan 3 //      twoIsLessThan [1;2;3] |> List.filter twoIsLessThan //   ""       printfn let printer = printfn "printing param=%i" //      printer    [1;2;3] |> List.iter printer 

प्रत्येक मामले में, हम एक आंशिक रूप से लागू फ़ंक्शन बनाते हैं जिसे विभिन्न स्थितियों में पुन: उपयोग किया जा सकता है।

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

 //    List.map let add1 = (+) 1 let add1ToEach = List.map add1 //   "add1"  List.map //  add1ToEach [1;2;3;4] //    List.filter let filterEvens = List.filter (fun i -> i%2 = 0) //    //  filterEvens [1;2;3;4] 

निम्नलिखित, अधिक जटिल उदाहरण दिखाता है कि एक ही दृष्टिकोण का उपयोग पारदर्शी रूप से "एम्बेडेड" व्यवहार बनाने के लिए कैसे किया जा सकता है।

• हम एक फ़ंक्शन बनाते हैं जो दो नंबर जोड़ता है, लेकिन इसके अलावा यह एक लॉगिंग फ़ंक्शन लेता है जो इन नंबरों और परिणाम को लॉग करेगा।
• लॉगिंग फ़ंक्शन दो पैरामीटर लेता है: (स्ट्रिंग) "नाम" और (जेनेरिक) "मूल्य", इसलिए इसमें हस्ताक्षर string->'a->unit ।
• फिर हम लॉगिंग फ़ंक्शन के विभिन्न कार्यान्वयन बनाते हैं, जैसे कि कंसोल लॉगगर या पॉप-अप आधारित लॉगर।
• और अंत में, हम आंशिक रूप से एक बंद लकड़हारा के साथ एक नया कार्य बनाने के लिए मुख्य कार्य को लागू करते हैं।

 //      - let adderWithPluggableLogger logger xy = logger "x" x logger "y" y let result = x + y logger "x+y" result result //  -      let consoleLogger argName argValue = printfn "%s=%A" argName argValue //           let addWithConsoleLogger = adderWithPluggableLogger consoleLogger addWithConsoleLogger 1 2 addWithConsoleLogger 42 99 //  -      let popupLogger argName argValue = let message = sprintf "%s=%A" argName argValue System.Windows.Forms.MessageBox.Show( text=message,caption="Logger") |> ignore //    -       let addWithPopupLogger = adderWithPluggableLogger popupLogger addWithPopupLogger 1 2 addWithPopupLogger 42 99 

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

 //         42 let add42WithConsoleLogger = addWithConsoleLogger 42 [1;2;3] |> List.map add42WithConsoleLogger [1;2;3] |> List.map add42 //     

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

आंशिक समारोह डिजाइन

जाहिर है, मापदंडों का क्रम आंशिक उपयोग की सुविधा को गंभीरता से प्रभावित कर सकता है। उदाहरण के लिए, List में अधिकांश कार्य जैसे List.map और List.filter का एक समान रूप है, अर्थात्:

 List-function [function parameter(s)] [list] 

सूची हमेशा अंतिम पैरामीटर होती है। पूर्ण रूप में कुछ उदाहरण:

 List.map (fun i -> i+1) [0;1;2;3] List.filter (fun i -> i>1) [0;1;2;3] List.sortBy (fun i -> -i ) [0;1;2;3] 

आंशिक अनुप्रयोग का उपयोग करने वाले समान उदाहरण:

 let eachAdd1 = List.map (fun i -> i+1) eachAdd1 [0;1;2;3] let excludeOneOrLess = List.filter (fun i -> i>1) excludeOneOrLess [0;1;2;3] let sortDesc = List.sortBy (fun i -> -i) sortDesc [0;1;2;3] 

यदि लाइब्रेरी कार्यों को तर्कों के एक अलग क्रम के साथ लागू किया गया था, तो आंशिक आवेदन बहुत कम सुविधाजनक होगा।

जब आप अपने कार्य को कई मापदंडों के साथ लिखते हैं, तो आप उनके सर्वोत्तम आदेश के बारे में सोच सकते हैं। सभी डिजाइन मुद्दों के साथ, कोई "सही" उत्तर नहीं है, लेकिन कई आम तौर पर स्वीकृत सिफारिशें हैं।

1. उन विकल्पों से शुरू करें जो स्थिर होने की संभावना है।
2. डेटा संरचना या संग्रह (या अन्य बदलते पैरामीटर) सेट करने के लिए अंतिम रहें
3. घटाव जैसे संचालन की बेहतर समझ के लिए, अपेक्षित आदेश का पालन करना उचित है

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

दूसरे सिरे का अनुसरण करने से पाइपलाइनिंग ऑपरेटर और संरचना का उपयोग करना आसान हो जाता है। हमने पहले ही इसे कई बार सूचियों के ऊपर के कार्यों के उदाहरणों में देखा है।

 //          let result = [1..10] |> List.map (fun i -> i+1) |> List.filter (fun i -> i>5) 

इसी प्रकार, सूचियों पर आंशिक रूप से लागू किए गए कार्य आसानी से रचना के संपर्क में हैं, क्योंकि सूची पैरामीटर छोड़ा जा सकता है:

 let compositeOp = List.map (fun i -> i+1) >> List.filter (fun i -> i>5) let result = compositeOp [1..10] 

आंशिक बीसीएल फ़ंक्शन रैपिंग

बेस क्लास लाइब्रेरी (BCL) .NET के कार्य F # से आसानी से सुलभ हैं, लेकिन वे F # जैसी कार्यात्मक भाषाओं में उपयोग पर भरोसा किए बिना डिज़ाइन किए गए हैं। उदाहरण के लिए, अधिकांश फ़ंक्शन को शुरुआत में डेटा पैरामीटर की आवश्यकता होती है, जबकि F # में डेटा पैरामीटर आमतौर पर अंतिम होना चाहिए।

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

 //     .NET  let replace oldStr newStr (s:string) = s.Replace(oldValue=oldStr, newValue=newStr) let startsWith lookFor (s:string) = s.StartsWith(lookFor) 

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

 let result = "hello" |> replace "h" "j" |> startsWith "j" ["the"; "quick"; "brown"; "fox"] |> List.filter (startsWith "f") 

या कार्यों की संरचना में:

 let compositeOp = replace "h" "j" >> startsWith "j" let result = compositeOp "hello" 

कन्वेयर ऑपरेटर को समझना

आपके द्वारा व्यवसाय में एक आंशिक अनुप्रयोग देखने के बाद, आप समझ सकते हैं कि कैसे पाइपलाइन किए गए कार्य काम करते हैं।

पाइपलाइनिंग फ़ंक्शन को निम्नानुसार परिभाषित किया गया है:

 let (|>) xf = fx 

वह जो करती है, उसे फंक्शन से पहले रखा जाता है, बाद में नहीं।

 let doSomething xyz = x+y+z doSomething 1 2 3 //     

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

यहाँ आंशिक उपयोग के लिए फिर से लिखा गया एक समान उदाहरण है।

 let doSomething xy = let intermediateFn z = x+y+z intermediateFn //  intermediateFn let doSomethingPartial = doSomething 1 2 doSomethingPartial 3 //       3 |> doSomethingPartial //    ,        

जैसा कि आपने देखा है, पाइपलाइन ऑपरेटर F # में बेहद सामान्य है, और इसका उपयोग जब भी आप डेटा के प्राकृतिक प्रवाह को संरक्षित करना चाहते हैं। कुछ और उदाहरण जो आपके सामने आ सकते हैं:

 "12" |> int //   "12"  int 1 |> (+) 2 |> (*) 3 //   

रिवर्स कंवायर ऑपरेटर

समय-समय पर, आप उलटा पाइप लाइन ऑपरेटर "<|" का सामना कर सकते हैं।

 let (<|) fx = fx 

यह फ़ंक्शन कुछ भी नहीं करता है, इसलिए इसका अस्तित्व क्यों है?

कारण यह है कि जब उलटा पाइपलाइन ऑपरेटर का उपयोग इन्फिक्स-स्टाइल बाइनरी ऑपरेटर के रूप में किया जाता है, तो यह कोष्ठकों की आवश्यकता को कम कर देता है, जिससे कोड क्लीनर बन जाता है।

 printf "%i" 1+2 //  printf "%i" (1+2) //   printf "%i" <| 1+2 //    

आप छद्म इन्फिक्स अंकन प्राप्त करने के लिए एक बार में दो दिशाओं में कन्वेयर का उपयोग कर सकते हैं।

 let add xy = x + y (1+2) add (3+4) //  1+2 |> add <| 3+4 //   

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

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

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

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

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

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

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

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

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