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

F # में, यह "प्रकार एक्सटेंशन" नामक एक सुविधा के साथ संभव है। कोई भी एफ # प्रकार, न केवल एक वर्ग, संलग्न कार्य हो सकता है।

यहाँ एक फ़ंक्शन को रिकॉर्ड प्रकार से संलग्न करने का एक उदाहरण है।

module Person = type T = {First:string; Last:string} with // -,     member this.FullName = this.First + " " + this.Last //  let create first last = {First=first; Last=last} let person = Person.create "John" "Doe" let fullname = person.FullName

ध्यान देने के लिए मुख्य बिंदु:

कीवर्ड के with सदस्य सूची की शुरुआत इंगित करता है।
member कीवर्ड इंगित करता है कि फ़ंक्शन एक सदस्य है (यानी एक विधि)
यह शब्द उस ऑब्जेक्ट का लेबल है जिस पर यह विधि कहा जाता है (इसे "स्व-पहचानकर्ता" भी कहा जाता है)। यह शब्द फ़ंक्शन नाम का उपसर्ग है, और फ़ंक्शन के अंदर आप इसका उपयोग वर्तमान उदाहरण को संदर्भित करने के लिए कर सकते हैं। स्व-पहचानकर्ता के रूप में उपयोग किए जाने वाले शब्दों के लिए कोई आवश्यकता नहीं है, यह पर्याप्त है कि वे स्थिर हैं। आप इसे self , me या किसी अन्य शब्द का उपयोग कर सकते हैं जो आमतौर पर स्वयं के संदर्भ के रूप में उपयोग किया जाता है।

एक प्रकार की घोषणा के साथ एक सदस्य को जोड़ने की कोई आवश्यकता नहीं है, आप हमेशा इसे बाद में उसी मॉड्यूल में जोड़ सकते हैं:

 module Person = type T = {First:string; Last:string} with // ,     member this.FullName = this.First + " " + this.Last //  let create first last = {First=first; Last=last} //  ,   type T with member this.SortableName = this.Last + ", " + this.First let person = Person.create "John" "Doe" let fullname = person.FullName let sortableName = person.SortableName

ये उदाहरण कॉल को "आंतरिक विस्तार" को प्रदर्शित करते हैं। वे एक प्रकार में संकलित किए जाते हैं और जहाँ भी उपयोग किया जाता है वहां उपलब्ध होगा। प्रतिबिंब का उपयोग करते समय उन्हें भी दिखाया जाएगा।

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

वैकल्पिक एक्सटेंशन

एक विकल्प पूरी तरह से अलग मॉड्यूल से एक अतिरिक्त सदस्य जोड़ना है। उन्हें "वैकल्पिक एक्सटेंशन" कहा जाता है। वे कक्षा के अंदर संकलन नहीं करते हैं, और उनके साथ काम करने के लिए एक अलग गुंजाइश मॉड्यूल की आवश्यकता होती है (यह व्यवहार C # से विस्तार विधियों जैसा दिखता है)।

उदाहरण के लिए, एक Person प्रकार को परिभाषित किया जाना चाहिए:

 module Person = type T = {First:string; Last:string} with // ,     member this.FullName = this.First + " " + this.Last //  let create first last = {First=first; Last=last} //   ,   type T with member this.SortableName = this.Last + ", " + this.First

नीचे दिए गए उदाहरण में दर्शाया गया है कि UppercaseName को दूसरे मॉड्यूल में कैसे जोड़ा जाए:

 //    module PersonExtensions = type Person.T with member this.UppercaseName = this.FullName.ToUpper()

अब आप इस एक्सटेंशन को आज़मा सकते हैं:

 let person = Person.create "John" "Doe" let uppercaseName = person.UppercaseName

उफ़, हमें एक त्रुटि मिलती है। ऐसा इसलिए हुआ क्योंकि PersonExtensions दायरे में नहीं हैं। जैसा कि C # में, किसी भी एक्सटेंशन का उपयोग करने के लिए, आपको उन्हें दायरे में दर्ज करना होगा।

एक बार जब हम ऐसा करते हैं, तो यह काम करेगा:

 //    ! open PersonExtensions let person = Person.create "John" "Doe" let uppercaseName = person.UppercaseName

सिस्टम प्रकार एक्सटेंशन

आप .NET पुस्तकालयों से प्रकारों का विस्तार भी कर सकते हैं। लेकिन यह ध्यान में रखा जाना चाहिए कि एक प्रकार का विस्तार करते समय, आपको इसके वास्तविक नाम का उपयोग करने की आवश्यकता है, न कि एक उपनाम।

उदाहरण के लिए, यदि आप int का विस्तार करने की कोशिश करते हैं, तो कुछ भी काम नहीं करेगा, क्योंकि int प्रकार के लिए मान्य नाम नहीं है:

 type int with member this.IsEven = this % 2 = 0

इसके बजाय, System.Int32 उपयोग करें:

 type System.Int32 with member this.IsEven = this % 2 = 0 let i = 20 if i.IsEven then printfn "'%i' is even" i

स्थैतिक सदस्य

आप स्थैतिक सदस्य कार्यों का उपयोग कर बना सकते हैं:

static जोड़ें
this टैग को हटा दें

 module Person = type T = {First:string; Last:string} with // ,     member this.FullName = this.First + " " + this.Last //   static member Create first last = {First=first; Last=last} let person = Person.T.Create "John" "Doe" let fullname = person.FullName

आप सिस्टम प्रकारों के लिए स्थैतिक सदस्य बना सकते हैं:

 type System.Int32 with static member IsOdd x = x % 2 = 1 type System.Double with static member Pi = 3.141 let result = System.Int32.IsOdd 20 let pi = System.Double.Pi

मौजूदा सुविधाओं को संलग्न करना

एक बहुत ही सामान्य पैटर्न एक प्रकार के मौजूदा स्वतंत्र कार्यों का लगाव है। यह कई फायदे प्रदान करता है:

विकास के दौरान, आप स्वतंत्र कार्यों की घोषणा कर सकते हैं जो अन्य स्वतंत्र कार्यों का संदर्भ देते हैं। यह विकास को सरल बना देगा, क्योंकि ऑब्जेक्ट-ओरिएंटेड एक ("पॉइंट टू पॉइंट") की तुलना में एक कार्यात्मक शैली के साथ प्रकार का अनुमान बहुत बेहतर काम करता है।
लेकिन कुछ प्रमुख कार्यों को एक प्रकार से जोड़ा जा सकता है। यह उपयोगकर्ताओं को यह चुनने की अनुमति देता है कि कौन सी शैलियों का उपयोग करना है - कार्यात्मक या ऑब्जेक्ट-उन्मुख।

इस तरह के समाधान का एक उदाहरण एफ # लाइब्रेरी से एक फ़ंक्शन है, जो सूची की लंबाई की गणना करता है। आप List मॉड्यूल से एक स्वतंत्र फ़ंक्शन का उपयोग कर सकते हैं या इसे उदाहरण विधि के रूप में कॉल कर सकते हैं।

 let list = [1..10] //   let len1 = List.length list // -  let len2 = list.Length

निम्नलिखित उदाहरण में, प्रकार में शुरू में कोई सदस्य नहीं होता है, फिर कई फ़ंक्शन परिभाषित होते हैं, और अंत में fullName प्रकार से जुड़ा होता है।

 module Person = // ,     type T = {First:string; Last:string} //  let create first last = {First=first; Last=last} //   let fullName {First=first; Last=last} = first + " " + last //       type T with member this.FullName = fullName this let person = Person.create "John" "Doe" let fullname = Person.fullName person //  let fullname2 = person.FullName //

fullName फ़ंक्शन का एक पैरामीटर, person । संलग्न सदस्य स्व-लिंक से पैरामीटर प्राप्त करता है।

मल्टीपल पैरामीटर्स के साथ मौजूदा फ़ंक्शंस जोड़ना

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

नीचे दिए गए उदाहरण में, hasSameFirstAndLastName फ़ंक्शन के तीन पैरामीटर हैं। हालांकि, संलग्न करते समय यह केवल एक का उल्लेख करने के लिए पर्याप्त है!

 module Person = //    type T = {First:string; Last:string} //  let create first last = {First=first; Last=last} //   let hasSameFirstAndLastName (person:T) otherFirst otherLast = person.First = otherFirst && person.Last = otherLast //      type T with member this.HasSameFirstAndLastName = hasSameFirstAndLastName this let person = Person.create "John" "Doe" let result1 = Person.hasSameFirstAndLastName person "bob" "smith" //  let result2 = person.HasSameFirstAndLastName "bob" "smith" //

यह काम क्यों करता है? संकेत: करी और आंशिक उपयोग के बारे में सोचो!

टपल तरीके

जब हमारे पास एक से अधिक पैरामीटर वाली विधियाँ हैं, तो आपको एक निर्णय लेने की आवश्यकता है:

हम मानक (करी) रूप का उपयोग कर सकते हैं, जहां पैरामीटर रिक्त स्थान द्वारा अलग किए जाते हैं, और आंशिक आवेदन का समर्थन किया जाता है।
या हम सभी मापदंडों को एक बार अल्पविराम द्वारा अलग किए गए टपल के रूप में पास कर सकते हैं।

क्यूर्ड फॉर्म अधिक कार्यात्मक है, जबकि टुपल फॉर्म अधिक ऑब्जेक्ट-ओरिएंटेड है।

एक tuple फॉर्म का उपयोग मानक .NET पुस्तकालयों के साथ F # के साथ बातचीत करने के लिए भी किया जाता है, इसलिए आपको इस दृष्टिकोण पर अधिक विस्तार से विचार करना चाहिए।

हमारी परीक्षण साइट दो तरीकों के साथ एक Product प्रकार होगी, जिनमें से प्रत्येक ऊपर वर्णित विधियों में से एक द्वारा कार्यान्वित किया जाता है। CurriedTotal और TupleTotal एक ही काम करते हैं: वे किसी दिए गए मात्रा और छूट के लिए उत्पाद की कुल लागत की गणना करते हैं।

 type Product = {SKU:string; Price: float} with //   member this.CurriedTotal qty discount = (this.Price * float qty) - discount //   member this.TupleTotal(qty,discount) = (this.Price * float qty) - discount

टेस्ट कोड:

 let product = {SKU="ABC"; Price=2.0} let total1 = product.CurriedTotal 10 1.0 let total2 = product.TupleTotal(10,1.0)

अभी तक बहुत अंतर नहीं है।

लेकिन हम जानते हैं कि करी संस्करण को आंशिक रूप से लागू किया जा सकता है:

 let totalFor10 = product.CurriedTotal 10 let discounts = [1.0..5.0] let totalForDifferentDiscounts = discounts |> List.map totalFor10

दूसरी ओर, टपल संस्करण कुछ ऐसा करने में सक्षम है जिसका नामकरण नहीं किया जा सकता, अर्थात्:

जिसका नाम पैरामीटर्स रखा गया है
वैकल्पिक पैरामीटर
अधिभार

एक ट्यूपल के रूप में मापदंडों के साथ नामित पैरामीटर

टपल दृष्टिकोण नामित मापदंडों का समर्थन करता है:

 let product = {SKU="ABC"; Price=2.0} let total3 = product.TupleTotal(qty=10,discount=1.0) let total4 = product.TupleTotal(discount=1.0, qty=10)

जैसा कि आप देख सकते हैं, यह आपको नामों को स्पष्ट रूप से निर्दिष्ट करके तर्कों के क्रम को बदलने की अनुमति देता है।

ध्यान दें: यदि केवल कुछ मापदंडों के नाम हैं, तो ये पैरामीटर हमेशा अंत में होने चाहिए।

ट्यूपल के रूप में मापदंडों के साथ वैकल्पिक पैरामीटर

ट्यूपल के रूप में मापदंडों के साथ तरीकों के लिए, आप पैरामीटर नाम के सामने एक प्रश्न चिह्न के रूप में उपसर्ग का उपयोग करके वैकल्पिक के रूप में चिह्नित कर सकते हैं।

यदि पैरामीटर सेट है, तो फ़ंक्शन के लिए Some value पारित किया जाएगा
नहीं तो None आएगा

एक उदाहरण:

 type Product = {SKU:string; Price: float} with //   member this.TupleTotal2(qty,?discount) = let extPrice = this.Price * float qty match discount with | None -> extPrice | Some discount -> extPrice - discount

और परीक्षण:

 let product = {SKU="ABC"; Price=2.0} //    let total1 = product.TupleTotal2(10) //   let total2 = product.TupleTotal2(10,1.0)

स्पष्ट रूप से None और Some लिए जाँच थकाऊ हो सकता है, लेकिन वैकल्पिक मापदंडों को संभालने के लिए अधिक सुरुचिपूर्ण समाधान है।

एक defaultArg फ़ंक्शन है जो पहले तर्क के रूप में एक पैरामीटर नाम लेता है और दूसरा के रूप में एक डिफ़ॉल्ट मान। यदि पैरामीटर सेट किया गया है, तो संबंधित मान वापस आ जाएगा; अन्यथा, डिफ़ॉल्ट मान।

एक ही कोड defaulArg का उपयोग करते defaulArg :

 type Product = {SKU:string; Price: float} with //   member this.TupleTotal2(qty,?discount) = let extPrice = this.Price * float qty let discount = defaultArg discount 0.0 extPrice - discount

विधि अधिभार

C # में, आप एक ही नाम से कई तरीके बना सकते हैं जो उनके हस्ताक्षर में भिन्न होते हैं (उदाहरण के लिए, विभिन्न प्रकार के पैरामीटर और / या उनकी संख्या)।

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

हालांकि, एफ # विधि ओवरलोडिंग का समर्थन करता है, लेकिन केवल तरीकों के लिए (जो कि प्रकारों से जुड़ा हुआ है) और केवल वे जो एक टुप शैली में लिखे गए हैं।

यहाँ TupleTotal विधि की एक और विविधता के साथ एक उदाहरण है!

 type Product = {SKU:string; Price: float} with //   member this.TupleTotal3(qty) = printfn "using non-discount method" this.Price * float qty //   member this.TupleTotal3(qty, discount) = printfn "using discount method" (this.Price * float qty) - discount

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

उपयोग उदाहरण:

 let product = {SKU="ABC"; Price=2.0} //    let total1 = product.TupleTotal3(10) //   let total2 = product.TupleTotal3(10,1.0)

अरे! इतनी जल्दी नहीं ... विधियों का उपयोग करने के नुकसान

एक वस्तु-उन्मुख दुनिया से आते हुए, आपको हर जगह तरीकों का उपयोग करने के लिए लुभाया जा सकता है, क्योंकि यह कुछ परिचित है। लेकिन आपको सावधान रहना चाहिए, क्योंकि उनके पास कई गंभीर कमियां हैं:

प्रकार के अनुमान से विधियां अच्छी तरह से काम नहीं करती हैं
उच्च क्रम के कार्यों के साथ तरीके अच्छी तरह से काम नहीं करते हैं

वास्तव में, तरीकों का दुरुपयोग करके, आप F # में प्रोग्रामिंग के सबसे शक्तिशाली और उपयोगी पहलुओं को याद कर सकते हैं।

आइए देखें कि मेरा क्या मतलब है।

विधियाँ प्रकार के अनुमानों के साथ खराब संपर्क करती हैं

आइए हम उस Person साथ उदाहरण पर लौटते हैं, जिसमें एक ही तर्क को एक स्वतंत्र कार्य और एक विधि में लागू किया गया था:

 module Person = //    type T = {First:string; Last:string} //  let create first last = {First=first; Last=last} //   let fullName {First=first; Last=last} = first + " " + last // - type T with member this.FullName = fullName this

अब देखते हैं कि प्रत्येक विधि के साथ किस प्रकार का अनुमान काम करता है। मान लीजिए मैं किसी व्यक्ति का पूरा नाम प्रिंट करना चाहता हूं, तो मैं printFullName फ़ंक्शन को परिभाषित printFullName , जो person को एक पैरामीटर के रूप में लेता है।

मॉड्यूल से एक स्वतंत्र फ़ंक्शन का उपयोग कर कोड:

 open Person //    let printFullName person = printfn "Name is %s" (fullName person) //    // val printFullName : Person.T -> unit

यह समस्याओं के बिना संकलित करता है, और प्रकार का अनुमान सही ढंग से Person रूप में पैरामीटर की पहचान करता है।

अब डॉट के माध्यम से संस्करण का प्रयास करें:

 open Person //    " " let printFullName2 person = printfn "Name is %s" (person.FullName)

यह कोड बिल्कुल भी संकलित नहीं करता है, क्योंकि प्रकार के अनुमान में पैरामीटर के प्रकार को निर्धारित करने के लिए पर्याप्त जानकारी नहीं है। किसी भी वस्तु को कार्यान्वित किया जा सकता है। .FullName - यह आउटपुट के लिए पर्याप्त नहीं है।

हां, हम एक फ़ंक्शन को एक पैरामीटर प्रकार के साथ एनोटेट कर सकते हैं, लेकिन इस वजह से, स्वचालित प्रकार की संपूर्णता का पूरा बिंदु खो जाता है।

उच्च-क्रम के कार्यों के साथ तरीके खराब हो जाते हैं

एक समान समस्या उच्च क्रम वाले कार्यों में उत्पन्न होती है। उदाहरण के लिए, लोगों की एक सूची है, और हमें उनके पूर्ण नामों की सूची प्राप्त करने की आवश्यकता है।

एक स्वतंत्र कार्य के मामले में, समाधान तुच्छ है:

 open Person let list = [ Person.create "Andy" "Anderson"; Person.create "John" "Johnson"; Person.create "Jack" "Jackson"] //     list |> List.map fullName

एक वस्तु विधि के मामले में, आपको हर जगह एक विशेष मेमना बनाना होगा:

 open Person let list = [ Person.create "Andy" "Anderson"; Person.create "John" "Johnson"; Person.create "Jack" "Jackson"] //    list |> List.map (fun p -> p.FullName)

लेकिन यह अभी भी एक काफी सरल उदाहरण है। वस्तुओं के तरीके रचना के लिए काफी अनुकूल हैं, पाइपलाइन में असुविधाजनक, आदि।

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

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

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

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

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

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

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

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

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

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