हम F # में कार्यात्मक प्रोग्रामिंग पर लेखों की हमारी श्रृंखला जारी रखते हैं। आज हम कार्यों की सहानुभूति और संरचना के बारे में बात करते हैं, साथ ही साथ संरचना और पाइपलाइन की तुलना करते हैं। बिल्ली के नीचे देखो!

सहयोग और कार्यों की संरचना

क्रियाशीलता

मान लीजिए कि एक पंक्ति में लिखे गए कार्यों की एक श्रृंखला है। उन्हें किस क्रम में संयोजित किया जाएगा?

उदाहरण के लिए, इस फ़ंक्शन का क्या मतलब है?

let F xyz = xyz

क्या इसका मतलब यह है कि फ़ंक्शन y को तर्क z लागू किया जाना चाहिए, और फिर परिणाम x को पास किया जाना चाहिए? यानी:

 let F xyz = x (yz)

या फ़ंक्शन x को तर्क y लागू किया जाता है, जिसके बाद परिणाम के रूप में प्राप्त फ़ंक्शन का तर्क z साथ मूल्यांकन किया जाएगा? यानी:

 let F xyz = (xy) z

दूसरा विकल्प सही है।
कार्यों के उपयोग ने संबद्धता छोड़ दी है ।
xyz अर्थ होता है (xy) z ।
और wxyz , ((wx) y) z बराबर है।
यह कमाल नहीं दिखना चाहिए।
हमने पहले ही देखा है कि आंशिक आवेदन कैसे काम करता है।
यदि हम x को दो मापदंडों के साथ एक फ़ंक्शन के रूप में बात करते हैं, तो (xy) z पहले पैरामीटर के एक आंशिक अनुप्रयोग का परिणाम है, जिसके बाद तर्क z को मध्यवर्ती फ़ंक्शन में पास किया जाता है।

यदि आपको सही संगति की आवश्यकता है, तो आप कोष्ठक या पाइप का उपयोग कर सकते हैं। निम्नलिखित तीन प्रविष्टियाँ समतुल्य हैं:

 let F xyz = x (yz) let F xyz = yz |> x //    let F xyz = x <| yz //

एक अभ्यास के रूप में, वास्तविक गणना के बिना इन कार्यों के हस्ताक्षर प्रदर्शित करने का प्रयास करें।

समारोह रचना

हमने कई बार कार्यों की संरचना का उल्लेख किया, लेकिन इस शब्द का वास्तव में क्या मतलब है? यह पहली नज़र में भयावह लगता है, लेकिन वास्तव में, सब कुछ काफी सरल है।

मान लें कि हमारे पास एक फ़ंक्शन "f" है जो "T1" प्रकार "T2" को मैप करता है। हमारे पास एक फ़ंक्शन "जी" है जो टाइप "टी 2" को "टी 3" टाइप करने के लिए परिवर्तित करता है। फिर हम "एफ" के आउटपुट और "जी" के इनपुट को जोड़ सकते हैं, एक नया फ़ंक्शन बना सकते हैं जो टाइप "टी 1" को "टी 3" टाइप करता है।

उदाहरण के लिए:

 let f (x:int) = float x * 3.0 // f  -  int->float let g (x:float) = x > 4.0 // g  -  float->bool

हम एक नया फ़ंक्शन "एच" बना सकते हैं जो "एफ" का आउटपुट लेता है और इसे "जी" के इनपुट के रूप में उपयोग करता है।

 let h (x:int) = let y = f(x) g(y) //    g

थोड़ा और कॉम्पैक्ट:

 let h (x:int) = g ( f(x) ) // h    int->bool // h 1 h 2

अब तक, इतना सरल। यह दिलचस्प है, हम एक नए फ़ंक्शन "कंपोज़" को परिभाषित कर सकते हैं, जो फ़ंक्शन "एफ" और "जी" लेता है और उनके हस्ताक्षर को भी जाने बिना उन्हें जोड़ती है।

 let compose fgx = g ( f(x) )

निष्पादन के बाद, आप देख सकते हैं कि संकलक ने सही ढंग से निर्णय लिया है कि " f " जेनेरिक प्रकार 'a से जेनेरिक प्रकार 'b का एक कार्य है, और ' g ' टाइप 'b इनपुट तक सीमित है:

 val compose : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c

(ध्यान दें कि संचालन की एक सामान्यीकृत संरचना केवल इसलिए संभव है क्योंकि प्रत्येक फ़ंक्शन में एक इनपुट पैरामीटर और एक आउटपुट होता है। गैर-कार्यात्मक भाषाओं में यह दृष्टिकोण संभव नहीं है।)

जैसा कि हम देख सकते हैं, इस परिभाषा का उपयोग " >> " ऑपरेटर के लिए किया जाता है।

 let (>>) fgx = g ( f(x) )

इस परिभाषा के लिए धन्यवाद, नए कार्यों को रचना का उपयोग करके मौजूदा कार्यों के आधार पर बनाया जा सकता है।

 let add1 x = x + 1 let times2 x = x * 2 let add1Times2 x = (>>) add1 times2 x // add1Times2 3

स्पष्ट रिकॉर्डिंग बहुत बोझिल है। लेकिन आप इसका उपयोग समझने में आसान बना सकते हैं।

सबसे पहले, आप पैरामीटर x से छुटकारा पा सकते हैं, और रचना एक आंशिक आवेदन लौटाएगी।

 let add1Times2 = (>>) add1 times2

दूसरी बात, क्योंकि >> एक बाइनरी ऑपरेटर है, आप इसे केंद्र में रख सकते हैं।

 let add1Times2 = add1 >> times2

रचना का उपयोग कोड क्लीनर और स्पष्ट बनाता है।

 let add1 x = x + 1 let times2 x = x * 2 //   let add1Times2 x = times2(add1 x) //   let add1Times2 = add1 >> times2

अभ्यास में रचना संचालक का उपयोग करना

कंपोजिशन ऑपरेटर (सभी इन्फिक्स ऑपरेटरों की तरह) के पास नियमित कार्यों की तुलना में कम प्राथमिकता है। इसका मतलब है कि संरचना में उपयोग किए गए कार्यों में कोष्ठक का उपयोग किए बिना तर्क हो सकते हैं।

उदाहरण के लिए, यदि "ऐड" और "टाइम्स" फ़ंक्शन में पैरामीटर हैं, तो उन्हें रचना के दौरान पारित किया जा सकता है।

 let add nx = x + n let times nx = x * n let add1Times2 = add 1 >> times 2 let add5Times3 = add 5 >> times 3 // add5Times3 1

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

 let twice f = f >> f // ('a -> 'a) -> ('a -> 'a)

ध्यान दें कि संकलक ने अनुमान लगाया है कि " f " एक ही प्रकार के मूल्यों को स्वीकार करता है और वापस करता है।

अब " + " फ़ंक्शन पर विचार करें। जैसा कि हमने पहले देखा, इनपुट (int->int) है, लेकिन आउटपुट वास्तव में (int->int) । इस प्रकार, " + " का उपयोग " twice " में किया जा सकता है। इसलिए, आप लिख सकते हैं:

 let add1 = (+) 1 //  (int -> int) let add1Twice = twice add1 //    (int -> int) // add1Twice 9

दूसरी ओर, आप नहीं लिख सकते हैं:

 let addThenMultiply = (+) >> (*)

क्योंकि इनपुट "*" एक int होना चाहिए, एक int->int फ़ंक्शन (जो इसके अतिरिक्त आउटपुट नहीं है)।

लेकिन अगर आप पहले फ़ंक्शन को सही करते हैं ताकि यह केवल int वापस आए, तो सब कुछ काम करेगा:

 let add1ThenMultiply = (+) 1 >> (*) // (+) 1   (int -> int)   'int' // add1ThenMultiply 2 7

यदि आवश्यक हो, तो रचना को " << " के माध्यम से रिवर्स ऑर्डर में भी प्रदर्शित किया जा सकता है:

 let times2Add1 = add 1 << times 2 times2Add1 3

रिवर्स रचना का उपयोग मुख्य रूप से कोड को अंग्रेजी ("अंग्रेजी जैसा") बनाने के लिए किया जाता है। उदाहरण के लिए:

 let myList = [] myList |> List.isEmpty |> not //   myList |> (not << List.isEmpty) //

रचना बनाम कन्वेयर

आप रचना और कन्वेयर के बीच छोटे अंतर से भ्रमित हो सकते हैं, जैसा कि वे बहुत समान दिख सकते हैं।

सबसे पहले, एक पाइपलाइन की परिभाषा देखें:

 let (|>) xf = fx

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

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

रचना समान नहीं है और पाइप के लिए प्रतिस्थापन नहीं हो सकती है। निम्नलिखित उदाहरण में, यहां तक कि संख्या 3 भी एक फ़ंक्शन नहीं है, इसलिए "आउटपुट" को doSomething को पारित नहीं किया जा सकता है:

 3 >> doSomething 1 2 //  // f >> g      g(f(x))     : doSomething 1 2 ( 3(x) ) //   3   ! // error FS0001: This expression was expected to have type 'a->'b // but here has type int

संकलक शिकायत करता है कि मान "3" एक प्रकार का फ़ंक्शन 'a->'b होना चाहिए।

इसकी तुलना रचना की परिभाषा से करें, जिसमें 3 तर्क होते हैं, जहाँ पहले दो कार्य होने चाहिए।

 let (>>) fgx = g ( f(x) ) let add nx = x + n let times nx = x * n let add1Times2 = add 1 >> times 2

रचना के बजाय पाइपलाइन का उपयोग करने के प्रयासों के परिणामस्वरूप संकलन त्रुटि होगी। निम्नलिखित उदाहरण में, " add 1 " (आंशिक) फ़ंक्शन int->int , जिसे " times 2 " के लिए दूसरे पैरामीटर के रूप में उपयोग नहीं किया जा सकता है।

 let add1Times2 = add 1 |> times 2 //  // x |> f      f(x)     : let add1Times2 = times 2 (add 1) // add1   'int' // error FS0001: Type mismatch. 'int -> int' does not match 'int'

संकलक शिकायत करता है कि " times 2 " को पैरामीटर को स्वीकार करना होगा int->int , अर्थात्। एक फंक्शन (int->int)->'a ।

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

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

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

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

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

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

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

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

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