यह एफ # में कार्यात्मक प्रोग्रामिंग पर लेखों की एक श्रृंखला के पहले से ही भाग 9 है! मुझे यकीन है कि हबेरा पर ऐसे बहुत लंबे चक्र नहीं हैं। लेकिन हम रुकने वाले नहीं हैं। आज हम नेस्टेड फ़ंक्शंस, मॉड्यूल, नेमस्पेस, और मिक्सिंग प्रकार और फ़ंक्शंस के बारे में बात करेंगे।

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

अब आप जानते हैं कि कार्यों को कैसे परिभाषित किया जाए, लेकिन उन्हें कैसे व्यवस्थित किया जाए?

एफ # में तीन विकल्प हैं:

• कार्यों को अन्य कार्यों में निहित किया जा सकता है।
• आवेदन स्तर पर, शीर्ष-स्तरीय कार्यों को "मॉड्यूल" में वर्गीकृत किया गया है।
• या आप ऑब्जेक्ट-ओरिएंटेड दृष्टिकोण का पालन कर सकते हैं और विधियों के रूप में कार्यों को संलग्न कर सकते हैं।

इस लेख में, हम पहले दो तरीकों पर विचार करेंगे, और शेष अगले में।

नेस्टेड कार्य

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

नीचे दिए गए उदाहरण में addThreeNumbers में addThreeNumbers :

 let addThreeNumbers xyz = //     let add n = fun x -> x + n //    x |> add y |> add z addThreeNumbers 2 3 4 

निहित कार्य सीधे मूल मापदंडों तक पहुंच सकते हैं, क्योंकि वे इसके दायरे में हैं।
तो, नीचे दिए गए उदाहरण में, printError नेस्टेड फ़ंक्शन printError मापदंडों की आवश्यकता नहीं है, क्योंकि वह सीधे n और max पहुंच सकता है।

 let validateSize max n = //       let printError() = printfn "Oops: '%i' is bigger than max: '%i'" n max //    if n > max then printError() validateSize 10 9 validateSize 10 11 

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

 let sumNumbersUpTo max = //      let rec recursiveSum n sumSoFar = match n with | 0 -> sumSoFar | _ -> recursiveSum (n-1) (n+sumSoFar) //       recursiveSum max 0 sumNumbersUpTo 10 

गहरी घोंसले के शिकार से बचने की कोशिश करें, विशेष रूप से माता-पिता चर के लिए सीधी पहुंच (मापदंडों के रूप में नहीं) के मामलों में।
बहुत गहराई से नेस्टेड फ़ंक्शंस को समझना मुश्किल होगा क्योंकि कई नेस्टेड अनिवार्य शाखाओं में से सबसे खराब है।

कैसे नहीं करना है इसका एक उदाहरण:

 // wtf,    ? let fx = let f2 y = let f3 z = x * z let f4 z = let f5 z = y * z let f6 () = y * x f6() f4 y x * f2 x 

मॉड्यूल

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

एक मॉड्यूल परिभाषा एक फ़ंक्शन परिभाषा के समान है। यह module कीवर्ड के साथ शुरू होता है, फिर module की सामग्री के बाद = चिन्ह आता है।
मॉड्यूल की सामग्री को एक ऑफसेट के साथ स्वरूपित किया जाना चाहिए, साथ ही कार्यों की परिभाषा में अभिव्यक्तियां भी।

दो कार्यों वाले एक मॉड्यूल की परिभाषा:

 module MathStuff = let add xy = x + y let subtract xy = x - y 

यदि आप Visual Studio में इस कोड को खोलते हैं, तो जब आप add ओवर करते add तो आप पूरा नाम add देख सकते हैं, जो वास्तव में MathStuff.add , जैसे कि MastStuff एक क्लास था, और add एक तरीका था।

वास्तव में, वास्तव में यही हो रहा है। पर्दे के पीछे, एफ # संकलक स्थिर तरीकों के साथ एक स्थिर वर्ग बनाता है। C # समतुल्य इस तरह दिखेगा:

 static class MathStuff { static public int add(int x, int y) { return x + y; } static public int subtract(int x, int y) { return x - y; } } 

यह पहचानते हुए कि मॉड्यूल केवल स्थिर वर्ग हैं और फ़ंक्शन स्थिर हैं विधियाँ F # में कैसे काम करती हैं, इसकी अच्छी समझ प्रदान करेगी, क्योंकि स्थैतिक कक्षाओं पर लागू होने वाले अधिकांश नियम मॉड्यूल पर भी लागू होते हैं।

और जिस तरह C # में, प्रत्येक स्टैंड-अलोन फंक्शन क्लास का हिस्सा होना चाहिए, F # में, प्रत्येक स्टैंड-अलोन फंक्शन मॉड्यूल का हिस्सा होना चाहिए।

मॉड्यूल के बाहर कार्यों तक पहुंच

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

 module MathStuff = let add xy = x + y let subtract xy = x - y module OtherStuff = //     MathStuff let add1 x = MathStuff.add x 1 

आप open निर्देश का उपयोग करके किसी अन्य मॉड्यूल के सभी कार्यों को भी आयात कर सकते हैं, जिसके बाद आप पूर्ण नाम के बजाय संक्षिप्त नाम का उपयोग कर सकते हैं।

 module OtherStuff = open MathStuff //      let add1 x = add x 1 

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

नेस्टेड मॉड्यूल

स्थिर वर्गों की तरह, मॉड्यूल में नेस्टेड मॉड्यूल हो सकते हैं:

 module MathStuff = let add xy = x + y let subtract xy = x - y //   module FloatLib = let add xy :float = x + y let subtract xy :float = x - y 

अन्य मॉड्यूल उपयुक्त या पूर्ण नाम के रूप में नेस्टेड मॉड्यूल में कार्यों को संदर्भित कर सकते हैं:

 module OtherStuff = open MathStuff let add1 x = add x 1 //   let add1Float x = MathStuff.FloatLib.add x 1.0 //   let sub1Float x = FloatLib.subtract x 1.0 

शीर्ष स्तर के मॉड्यूल

इस प्रकार, चूंकि मॉड्यूल को नेस्ट किया जा सकता है, इसलिए, श्रृंखला में ऊपर जाकर, आप शीर्ष स्तर के कुछ मूल मॉड्यूल तक पहुंच सकते हैं। यह वास्तव में है।

शीर्ष-स्तर के मॉड्यूल अलग-अलग परिभाषित किए जाते हैं, उन मॉड्यूलों के विपरीत जो पहले दिखाए गए थे।

• module MyModuleName फ़ाइल में पहली घोषणा होनी चाहिए
• चिन्ह = गायब
• मॉड्यूल सामग्री को इंडेंट नहीं किया जाना चाहिए

सामान्य तौर पर, प्रत्येक स्रोत .FS फ़ाइल में एक "शीर्ष-स्तरीय" घोषणा मौजूद होनी चाहिए। कुछ अपवाद हैं, लेकिन यह अभी भी अच्छा अभ्यास है। मॉड्यूल नाम को फ़ाइल नाम से मेल नहीं खाता है, लेकिन दो फ़ाइलों में समान नाम वाले मॉड्यूल नहीं हो सकते हैं।

.FSX फ़ाइलों के लिए, मॉड्यूल घोषणा की आवश्यकता नहीं है, इस मामले में स्क्रिप्ट फ़ाइल नाम स्वचालित रूप से मॉड्यूल नाम बन जाता है।

एक "शीर्ष मॉड्यूल" मॉड्यूल के रूप में घोषित MathStuff का एक उदाहरण:

 //    module MathStuff let add xy = x + y let subtract xy = x - y //   module FloatLib = let add xy :float = x + y let subtract xy :float = x - y 

ध्यान दें कि "शीर्ष-स्तरीय" कोड ( module MathStuff ) में कोई इंडेंटेशन नहीं है, जबकि नेस्टेड FloatLib मॉड्यूल की सामग्री को अभी भी इंडेंट किया जाना है।

अन्य मॉड्यूल सामग्री

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

 module MathStuff = //  let add xy = x + y let subtract xy = x - y //   type Complex = {r:float; i:float} type IntegerFunction = int -> int -> int type DegreesOrRadians = Deg | Rad // "" let PI = 3.141 // "" let mutable TrigType = Deg //  /   do printfn "module initialized" 

वैसे, यदि आप इन उदाहरणों को अंतःक्रियात्मक रूप से चलाते हैं, तो आपको सत्र को अक्सर पर्याप्त रूप से पुनरारंभ करने की आवश्यकता हो सकती है ताकि कोड "ताज़ा" बना रहे और पिछले गणनाओं से संक्रमित न हो।

कंसीलरेशन (ओवरलैपिंग, शैडोइंग)

यह फिर से हमारा नमूना मॉड्यूल है। ध्यान दें कि MathStuff में add फंक्शन के साथ- साथ FloatLib ।

 module MathStuff = let add xy = x + y let subtract xy = x - y //   module FloatLib = let add xy :float = x + y let subtract xy :float = x - y 

यदि आप वर्तमान दायरे और कॉल add में दोनों मॉड्यूल खोलते हैं तो क्या होगा?

 open MathStuff open MathStuff.FloatLib let result = add 1 2 // Compiler error: This expression was expected to // have type float but here has type int 

और ऐसा हुआ कि MathStuff.FloatLib मॉड्यूल ने मूल MathStuff फिर से परिभाषित किया, जो कि FloatLib मॉड्यूल द्वारा अवरुद्ध (छिपा हुआ) था।

परिणामस्वरूप, हमें FS0001 संकलक त्रुटि मिलती है, क्योंकि पहले पैरामीटर 1 को फ्लोट के रूप में अपेक्षित था। इसे ठीक करने के लिए, आपको 1 से 1.0 बदलना होगा।

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

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

 [<RequireQualifiedAccess>] module MathStuff = let add xy = x + y let subtract xy = x - y //   [<RequireQualifiedAccess>] module FloatLib = let add xy :float = x + y let subtract xy :float = x - y 

अब open निर्देश उपलब्ध नहीं है:

 open MathStuff //  open MathStuff.FloatLib //  

लेकिन आप अभी भी फ़ंक्शन (बिना किसी अस्पष्टता के) का उपयोग अपने पूर्ण नामों के माध्यम से कर सकते हैं:

 let result = MathStuff.add 1 2 let result = MathStuff.FloatLib.add 1.0 2.0 

अभिगम नियंत्रण

एफ # public , private और internal जैसे मानक .NET एक्सेस कंट्रोल ऑपरेटरों के उपयोग का समर्थन करता है। MSDN आलेख में पूरी जानकारी है।

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

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

नामस्थान

F # में नाम स्थान C # से नामस्थान के समान हैं। उनका उपयोग मॉड्यूल और प्रकारों को व्यवस्थित करने के लिए किया जा सकता है ताकि नाम संघर्ष से बचा जा सके।

namespace कीवर्ड का उपयोग करके घोषित एक नामस्थान:

 namespace Utilities module MathStuff = //  let add xy = x + y let subtract xy = x - y 

इस नाम स्थान के कारण, MathStuff मॉड्यूल MathStuff पूरा नाम Utilities.MathStuff बन गया है, और पूरा नाम add लिए Utilities.MathStuff.add ।

समान इंडेंटेशन नियम एक नेमस्पेस के भीतर मॉड्यूल पर लागू होते हैं जो मॉड्यूल के लिए ऊपर दिखाए गए थे।

आप मॉड्यूल नाम में एक अवधि जोड़कर स्पष्ट रूप से एक नाम स्थान की घोषणा कर सकते हैं। यानी उपरोक्त कोड को इस तरह से फिर से लिखा जा सकता है:

 module Utilities.MathStuff //  let add xy = x + y let subtract xy = x - y 

MathStuff मॉड्यूल का पूरा नाम अभी भी Utilities.MathStuff है। MathStuff , लेकिन अब यह एक शीर्ष-स्तरीय मॉड्यूल है और इसकी सामग्री को इंडेंटेशन की आवश्यकता नहीं है।

नाम स्थान का उपयोग करने के लिए कुछ अतिरिक्त विशेषताएं:

• मॉड्यूल के लिए नाम स्थान वैकल्पिक हैं। C # के विपरीत, F # प्रोजेक्ट्स के लिए कोई डिफ़ॉल्ट नेमस्पेस नहीं है, इसलिए बिना नाम के टॉप-लेवल मॉड्यूल ग्लोबल होगा। यदि आप पुन: प्रयोज्य पुस्तकालयों को बनाने की योजना बनाते हैं, तो आपको अन्य पुस्तकालयों के कोड के साथ संघर्ष से बचने के लिए कई नामस्थान जोड़ना होगा।
• नाम स्थान में सीधे प्रकार की घोषणाएँ हो सकती हैं, लेकिन फ़ंक्शन की घोषणाएँ नहीं। जैसा कि पहले उल्लेख किया गया है, सभी फ़ंक्शन और मूल्य घोषणाएं एक मॉड्यूल का हिस्सा होनी चाहिए।
• अंत में, ध्यान रखें कि नामस्थान स्क्रिप्ट में काम नहीं करते हैं। उदाहरण के लिए, यदि आप एक नाम स्थान घोषणाएँ भेजने की कोशिश करते हैं, जैसे कि namespace Utilities , एक इंटरैक्टिव विंडो में, एक त्रुटि प्राप्त होती है।

नामस्थान पदानुक्रम

आप बस नाम को डॉट्स के साथ विभाजित करके नामस्थानों का एक पदानुक्रम बना सकते हैं:

 namespace Core.Utilities module MathStuff = let add xy = x + y 

आप चाहें तो एक फ़ाइल में दो नामस्थान भी घोषित कर सकते हैं। यह ध्यान दिया जाना चाहिए कि सभी नामस्थानों को उनके पूर्ण नाम द्वारा घोषित किया जाना चाहिए - वे घोंसले के शिकार का समर्थन नहीं करते हैं।

 namespace Core.Utilities module MathStuff = let add xy = x + y namespace Core.Extra module MoreMathStuff = let add xy = x + y 

नाम स्थान और मॉड्यूल के बीच एक नाम संघर्ष संभव नहीं है।

 namespace Core.Utilities module MathStuff = let add xy = x + y namespace Core //    - Core.Utilities //     ! module Utilities = let add xy = x + y 

मॉड्यूल में प्रकार और कार्यों को मिलाकर

जैसा कि हमने देखा है, मॉड्यूल आमतौर पर कई अंतरनिर्भर कार्यों से मिलकर बनता है जो एक विशेष डेटा प्रकार के साथ बातचीत करते हैं।

OOP में, डेटा संरचनाएं और उनके ऊपर के कार्य एक वर्ग के भीतर एक साथ जोड़ दिए जाएंगे। और कार्यात्मक एफ # में, डेटा संरचनाएं और उनके ऊपर के कार्य एक मॉड्यूल में संयुक्त होते हैं।

प्रकार और कार्यों के संयोजन के लिए दो पैटर्न हैं:

• प्रकार को कार्यों से अलग घोषित किया जाता है
• फ़ंक्शन के रूप में एक ही मॉड्यूल में प्रकार घोषित किया जाता है

पहले मामले में, किसी भी मॉड्यूल (लेकिन नाम स्थान में) के बाहर प्रकार घोषित किया जाता है, जिसके बाद इस प्रकार के साथ काम करने वाले कार्यों को उसी प्रकार के मॉड्यूल में रखा जाता है।

 //    namespace Example //      type PersonType = {First:string; Last:string} //    ,     module Person = //  let create first last = {First=first; Last=last} // ,     let fullName {First=first; Last=last} = first + " " + last let person = Person.create "john" "doe" Person.fullName person |> printfn "Fullname=%s" 

वैकल्पिक रूप से, प्रकार को मॉड्यूल के अंदर घोषित किया गया है और इसका एक सरल नाम है जैसे " T " या मॉड्यूल का नाम। कार्यों की पहुँच लगभग इस प्रकार है: MyModule.Func और MyModule.Func2 , और इस प्रकार की पहुँच: MyModule.T :

 module Customer = // Customer.T -      type T = {AccountId:int; Name:string} //  let create id name = {T.AccountId=id; T.Name=name} // ,     let isValid {T.AccountId=id; } = id > 0 let customer = Customer.create 42 "bob" Customer.isValid customer |> printfn "Is valid?=%b" 

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

तो कौन सा रास्ता चुनना है?

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

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

केवल प्रकार वाले मॉड्यूल

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

उदाहरण के लिए, आप ऐसा करना चाह सकते हैं:

 //    module Example //     type PersonType = {First:string; Last:string} //    ,  ... 

और यहाँ भी ऐसा ही करने का एक और तरीका है। module शब्द बस namespace साथ बदल दिया गया है।

 //    namespace Example //     type PersonType = {First:string; Last:string} 

दोनों मामलों में, PersonType का पूरा नाम एक ही होगा।

कृपया ध्यान दें कि यह प्रतिस्थापन केवल प्रकारों के साथ काम करता है। मॉड्यूल के अंदर फंक्शंस को हमेशा घोषित किया जाना चाहिए।

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

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

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

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

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

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

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

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

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