आज हम कार्यात्मक प्रोग्रामिंग पर लेखों की अपनी श्रृंखला समाप्त कर रहे हैं। यह 11 भागों में बदल गया। मेरा मानना ​​है कि यह एक उपलब्धि है। इस लेख में, हम एक साधारण स्टैक कैलकुलेटर ("रिवर्स पोलिश नोटेशन" के रूप में भी जाना जाता है) को लागू करते हैं। कार्यान्वयन लगभग पूरी तरह से कार्यों पर बनाया गया है, केवल एक विशेष प्रकार के साथ, और आम तौर पर नमूना की तुलना किए बिना, इसलिए यह हमारी श्रृंखला में शामिल अवधारणाओं के लिए एक उत्कृष्ट परीक्षण मैदान है।

मैं @kleidemos को अलग से धन्यवाद देना चाहता हूं। यह वह था जिसने लेखों की पूरी श्रृंखला के मुख्य अनुवादक और प्रबंधक के रूप में काम किया। धन्यवाद!

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

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

स्टैक पर सरल संगणना की योजना:

ऐसी प्रणाली को डिजाइन करने से पहले, आपको यह विचार करना चाहिए कि इसका उपयोग कैसे किया जाएगा। फोर्थ-जैसे सिंटैक्स के बाद, हम प्रत्येक कार्रवाई को एक उपयुक्त लेबल देंगे ताकि ऊपर दिए गए उदाहरण में आप कुछ लिख सकें:

EMPTY ONE THREE ADD TWO MUL SHOW 

शायद इस वाक्यविन्यास को प्राप्त करना असंभव है, लेकिन चलो जितना संभव हो उतना करीब आने की कोशिश करें।

स्टैक डेटा प्रकार

सबसे पहले, आपको स्टैक के लिए डेटा संरचना को परिभाषित करने की आवश्यकता है। सादगी के लिए, आप फ़्लोटिंग पॉइंट नंबरों की सूची का उपयोग कर सकते हैं।

 type Stack = float list 

लेकिन इस प्रकार के दृश्य को अधिक बनाने के लिए इसे एकल केस यूनियन प्रकार में लपेटना बेहतर है:

 type Stack = StackContents of float list 

ऐसा करना बेहतर क्यों है, आप यहाँ पढ़ सकते हैं।

अब एक निर्माता के रूप में StackContents का उपयोग करके एक नया स्टैक बनाएं:

 let newStack = StackContents [1.0;2.0;3.0] 

मौजूदा स्टैक से सामग्री निकालने के लिए, StackContents मेल खाते पैटर्न का उपयोग करें:

 let (StackContents contents) = newStack //  "contents"   // float list = [1.0; 2.0; 3.0] 

पुश कार्य

अगला, हमें इस स्टैक पर नंबर डालने का एक तरीका चाहिए। ऐसा करने के लिए, बस " :: " का उपयोग करके सूची के शीर्ष पर एक नया मान जोड़ें।

समारोह का उदाहरण:

 let push x aStack = let (StackContents contents) = aStack let newContents = x::contents StackContents newContents 

इस सुविधा में कई विशेषताएं हैं जो चर्चा के लायक हैं।

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

 Input: Stack   -  Output:  Stack 

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

अंत में, फ़ंक्शन बॉडी में let बजाय, फ़ंक्शन पैरामीटर में पैटर्न के साथ मिलान करके फ़ंक्शन को अधिक संक्षिप्त बनाया जा सकता है।

लिखित संस्करण:

 let push x (StackContents contents) = StackContents (x::contents) 

बहुत बेहतर!

वैसे, उसके सुंदर हस्ताक्षर देखें:

 val push : float -> Stack -> Stack 

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

एक तरीका या दूसरा, जांचें:

 let emptyStack = StackContents [] let stackWith1 = push 1.0 emptyStack let stackWith2 = push 2.0 stackWith1 

महान काम करता है!

पुश का उपयोग करके शीर्ष सुपरस्क्रिप्ट को स्टैक करें

इस सरल फ़ंक्शन के साथ, आप एक ऑपरेशन को आसानी से परिभाषित कर सकते हैं जो स्टैक पर एक विशिष्ट संख्या को धक्का देता है।

 let ONE stack = push 1.0 stack let TWO stack = push 2.0 stack 

लेकिन एक मिनट रुकिए! आप देखते हैं कि stack पैरामीटर का उल्लेख अभिव्यक्ति के दोनों किनारों पर किया गया है? वास्तव में, दो बार इसका उल्लेख करना आवश्यक नहीं है। इसके बजाय, आप पैरामीटर को छोड़ सकते हैं और आंशिक अनुप्रयोग के साथ एक फ़ंक्शन लिख सकते हैं:

 let ONE = push 1.0 let TWO = push 2.0 let THREE = push 3.0 let FOUR = push 4.0 let FIVE = push 5.0 

अब यह स्पष्ट है कि यदि push फ़ंक्शन में मापदंडों का एक अलग क्रम था, तो stack को दो बार उल्लेख करना होगा।

यह एक फ़ंक्शन को परिभाषित करने के लायक भी है जो एक खाली स्टैक बनाता है:

 let EMPTY = StackContents [] 

प्राप्त कार्यों की जाँच करें:

 let stackWith1 = ONE EMPTY let stackWith2 = TWO stackWith1 let stackWith3 = THREE stackWith2 

क्या ये मध्यवर्ती ढेर कष्टप्रद हैं? क्या इनसे छुटकारा पाना संभव है? बेशक! ध्यान दें कि एक, दो और तीन कार्यों में एक ही हस्ताक्षर हैं:

 Stack -> Stack 

तो, वे पूरी तरह से एक साथ जुड़े हुए हैं! एक फ़ंक्शन का आउटपुट निम्न में इनपुट हो सकता है:

 let result123 = EMPTY |> ONE |> TWO |> THREE let result312 = EMPTY |> THREE |> ONE |> TWO 

ढेर से बाहर निकलना

स्टैक के अतिरिक्त के साथ पता लगा, लेकिन pop समारोह के बारे में क्या?

स्टैक से पुनर्प्राप्त करते समय, स्टैक के शीर्ष को वापस करना स्पष्ट रूप से आवश्यक है, लेकिन क्या यह सिर्फ इतना है?

ऑब्जेक्ट-ओरिएंटेड शैली में, उत्तर हां है । लेकिन ओओपी के मामले में, पर्दे के पीछे ढेर को बदल दिया जाएगा, ताकि शीर्ष वस्तु को हटा दिया जाए।

हालांकि, एक कार्यात्मक शैली में, स्टैक अपरिवर्तनीय है। शीर्ष तत्व को हटाने का केवल एक ही तरीका है - इस तत्व के बिना एक नया स्टैक बनाएं। कॉल करने वाले के लिए नए घटे हुए स्टैक तक पहुंच के लिए, इसे शीर्ष तत्व के साथ वापस करना होगा।

दूसरे शब्दों में, pop फ़ंक्शन को दो मान, शीर्ष तत्व और नया स्टैक वापस करना चाहिए। F # में ऐसा करने का सबसे सरल तरीका केवल एक टुपल का उपयोग करना है।

कार्यान्वयन:

 ///     ///          let pop (StackContents contents) = match contents with | top::rest -> let newStack = StackContents rest (top,newStack) 

परिणामी फ़ंक्शन भी बहुत सरल है।

पहले की तरह, contents सीधे पैरामीटर से निकाली जाती है।

फिर, सामग्री की contents का match..with है।

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

इस कोड को चलाने का प्रयास करें और देखें कि क्या होता है। आपको एक संकलन त्रुटि मिलेगी!
संकलक ने एक ऐसे मामले का पता लगाया है, जिस पर काम नहीं किया गया है - यदि स्टैक खाली है तो क्या होगा?

आपको यह तय करना होगा कि इसे कैसे संभालना है।

• विकल्प 1: विशेष स्थिति "सफलता" या "त्रुटि" लौटाएं, जैसा कि श्रृंखला से पोस्ट में किया गया था "एफ # का उपयोग क्यों करें?" ।
• विकल्प 2: एक अपवाद फेंकें।

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

 let pop (StackContents contents) = match contents with | top::rest -> let newStack = StackContents rest (top,newStack) | [] -> failwith "Stack underflow" 

की जाँच करें:

 let initialStack = EMPTY |> ONE |> TWO let popped1, poppedStack = pop initialStack let popped2, poppedStack2 = pop poppedStack 

और अपवाद परीक्षण:

 let _ = pop EMPTY 

अंकगणितीय कार्य

अब जब जोड़ और विलोपन हो रहे हैं, तो आप "ऐड" और "गुणा" कार्यों के साथ काम करना शुरू कर सकते हैं:

 let ADD stack = let x,s = pop stack //   let y,s2 = pop s //    let result = x + y //   push result s2 //     let MUL stack = let x,s = pop stack //   let y,s2 = pop s //    let result = x * y //   push result s2 //     

ऑनलाइन परीक्षण:

 let add1and2 = EMPTY |> ONE |> TWO |> ADD let add2and3 = EMPTY |> TWO |> THREE |> ADD let mult2and3 = EMPTY |> TWO |> THREE |> MUL 

यह काम करता है!

समय निकालकर ...

जाहिर है, इन दोनों कार्यों में कोड की एक महत्वपूर्ण राशि की नकल की जाती है। हम इसे कैसे ठीक कर सकते हैं?

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

 let binary mathFn stack = //    let y,stack' = pop stack //     let x,stack'' = pop stack' //  let z = mathFn xy //      push z stack'' 

ध्यान दें कि इस कार्यान्वयन में, "समान" ऑब्जेक्ट के विभिन्न संस्करणों को अलग-अलग उद्धरण चिह्नों के साथ चिह्नित किया गया है। ऐसा इसलिए है क्योंकि संख्यात्मक प्रत्यय आसानी से भ्रम की स्थिति पैदा कर सकते हैं।

प्रश्न: stack बाद आने वाले mathFn बजाय मापदंडों का वास्तव में यह आदेश क्यों है?

अब जब आपके पास एक binary फ़ंक्शन है, तो ADD और अन्य कार्यों को परिभाषित करना बहुत आसान है:

binary का उपयोग करके ADD को लागू करने का पहला प्रयास:

 let ADD aStack = binary (fun xy -> x + y) aStack 

लेकिन आप लंबोदर से छुटकारा पा सकते हैं, क्योंकि यह अंतर्निहित फ़ंक्शन + की सटीक परिभाषा का प्रतिनिधित्व करता है:

 let ADD aStack = binary (+) aStack 

फिर से, स्टैक पैरामीटर को छिपाने के लिए एक आंशिक एप्लिकेशन का उपयोग किया जा सकता है। अंतिम परिभाषा:

 let ADD = binary (+) 

अन्य गणितीय कार्यों की परिभाषा:

 let SUB = binary (-) let MUL = binary (*) let DIV = binary (../) 

इसे ऑनलाइन आज़माएं:

 let div2by3 = EMPTY |> THREE|> TWO |> DIV let sub2from5 = EMPTY |> TWO |> FIVE |> SUB let add1and2thenSub3 = EMPTY |> ONE |> TWO |> ADD |> THREE |> SUB 

इसी तरह, आप एकतरफा संचालन के लिए एक सहायक फ़ंक्शन बना सकते हैं

 let unary f stack = let x,stack' = pop stack push (fx) stack' 

और कुछ एकात्मक कार्यों को परिभाषित करें:

 let NEG = unary (fun x -> -x) let SQUARE = unary (fun x -> x * x) 

इंटरएक्टिव मोड:

 let neg3 = EMPTY |> THREE|> NEG let square2 = EMPTY |> TWO |> SQUARE 

यह सब एक साथ रखना | यह सब एक साथ रखना

प्रारंभिक आवश्यकताओं में यह उल्लेख किया गया था कि हम परिणाम दिखाना चाहते हैं, इसलिए यह SHOW फ़ंक्शन को परिभाषित करने के लायक है।

 let SHOW stack = let x,_ = pop stack printfn "The answer is %f" x stack //       

कृपया ध्यान दें कि इस स्थिति में, pop माध्यम से प्राप्त स्टैक के नए संस्करण को अनदेखा किया जाता है। अंतिम परिणाम मूल स्टैक है, जैसे कि यह कभी नहीं बदला था।

अंत में, आप मूल आवश्यकताओं से निम्नलिखित उदाहरण लिख सकते हैं

 EMPTY |> ONE |> THREE |> ADD |> TWO |> MUL |> SHOW 

आगे बढ़ते हैं

यह मजेदार है, लेकिन आप और क्या कर सकते हैं?

आप कई अतिरिक्त कार्यों को परिभाषित कर सकते हैं:

 ///      let DUP stack = //    let x,_ = pop stack //      push x stack ///      let SWAP stack = let x,s = pop stack let y,s' = pop s push y (push x s') ///    let START = EMPTY 

इन अतिरिक्त कार्यों का उपयोग करके, आप कुछ सुरुचिपूर्ण उदाहरण लिख सकते हैं:

 START |> ONE |> TWO |> SHOW START |> ONE |> TWO |> ADD |> SHOW |> THREE |> ADD |> SHOW START |> THREE |> DUP |> DUP |> MUL |> MUL // 27 START |> ONE |> TWO |> ADD |> SHOW // 3 |> THREE |> MUL |> SHOW // 9 |> TWO |> SWAP |> DIV |> SHOW // 9 div 2 = 4.5 

पाइपलाइनिंग के बजाय रचना का उपयोग करना

लेकिन यह सब नहीं है। वास्तव में, इन कार्यों का प्रतिनिधित्व करने का एक और दिलचस्प तरीका है।

जैसा कि पहले उल्लेख किया गया है, वे सभी एक ही हस्ताक्षर हैं:

 Stack -> Stack 

चूंकि इनपुट और आउटपुट एक ही प्रकार के होते हैं, इन कार्यों को कंपोजिशन ऑपरेटर >> का उपयोग करके भी जोड़ा जा सकता है, न कि केवल पाइपलाइन किए गए ऑपरेटरों के माध्यम से।

कुछ उदाहरण:

 //    let ONE_TWO_ADD = ONE >> TWO >> ADD START |> ONE_TWO_ADD |> SHOW //    let SQUARE = DUP >> MUL START |> TWO |> SQUARE |> SHOW //     let CUBE = DUP >> DUP >> MUL >> MUL START |> THREE |> CUBE |> SHOW //   let SUM_NUMBERS_UPTO = DUP // n >> ONE >> ADD // n+1 >> MUL // n(n+1) >> TWO >> SWAP >> DIV // n(n+1) / 2 START |> THREE |> SQUARE |> SUM_NUMBERS_UPTO |> SHOW 

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

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

हमने अपने मॉडल का उपयोग करने के दो अलग-अलग तरीके देखे; कन्वेयर और रचना का उपयोग करना। लेकिन फर्क क्या है? और एक को दूसरे पर क्यों पसंद किया जाना चाहिए?

अंतर यह है कि पाइपलाइन एक मायने में, "वास्तविक समय में परिवर्तन" ऑपरेशन है। पाइप लाइन का उपयोग करने के समय, एक विशिष्ट स्टैक के हस्तांतरण के माध्यम से तुरंत संचालन किया जाता है।

दूसरी ओर, रचना एक "योजना" की तरह है जिसे हम सीधे आवेदन के बिना घटकों के एक सेट से कार्यों को लागू करना चाहते हैं।

उदाहरण के लिए, आप छोटे ऑपरेशन के संयोजन के माध्यम से एक संख्या के वर्ग की गणना के लिए एक "योजना" बना सकते हैं:

 let COMPOSED_SQUARE = DUP >> MUL 

मैं पाइपलाइनों के आधार पर समकक्ष नहीं दे सकता।

 let PIPED_SQUARE = DUP |> MUL 

यह एक संकलन त्रुटि के परिणामस्वरूप होगा। मुझे अभिव्यक्ति के लिए कुछ विशिष्ट स्टैक उदाहरण की आवश्यकता है:

 let stackWith2 = EMPTY |> TWO let twoSquared = stackWith2 |> DUP |> MUL 

और इस मामले में भी, मुझे केवल इस विशेष इनपुट के लिए एक उत्तर मिल सकता है, न कि किसी इनपुट के आधार पर सामान्यीकृत गणना योजना, जैसा कि COMPOSED_SQUARE साथ उदाहरण में है।

"योजना" बनाने का एक और तरीका स्पष्ट रूप से लंबोदर को अधिक आदिम कार्यों के लिए पारित करना है:

 let LAMBDA_SQUARE = unary (fun x -> x * x) 

यह एक अधिक स्पष्ट तरीका है (और सबसे अधिक तेजी से संभव है), लेकिन संरचनात्मक दृष्टिकोण के सभी फायदे और स्पष्टता खो जाती है।

सामान्य तौर पर, यदि संभव हो, तो आपको एक संरचनागत दृष्टिकोण के लिए प्रयास करना चाहिए!

पूर्ण कोड

उपरोक्त सभी उदाहरणों के लिए पूर्ण कोड:

 // ============================================== //  // ============================================== type Stack = StackContents of float list // ============================================== //   // ============================================== ///     let push x (StackContents contents) = StackContents (x::contents) ///        ///       let pop (StackContents contents) = match contents with | top::rest -> let newStack = StackContents rest (top,newStack) | [] -> failwith "Stack underflow" // ============================================== //  () // ============================================== //     //      //     let binary mathFn stack = let y,stack' = pop stack let x,stack'' = pop stack' let z = mathFn xy push z stack'' //    //      //     let unary f stack = let x,stack' = pop stack push (fx) stack' // ============================================== //  () // ============================================== ///      let SHOW stack = let x,_ = pop stack printfn "The answer is %f" x stack //      ///    let DUP stack = let x,s = pop stack push x (push xs) ///      let SWAP stack = let x,s = pop stack let y,s' = pop s push y (push x s') ///    let DROP stack = let _,s = pop stack //   s //   // ============================================== // ,    // ============================================== //  // ------------------------------- let EMPTY = StackContents [] let START = EMPTY //  // ------------------------------- let ONE = push 1.0 let TWO = push 2.0 let THREE = push 3.0 let FOUR = push 4.0 let FIVE = push 5.0 //   // ------------------------------- let ADD = binary (+) let SUB = binary (-) let MUL = binary (*) let DIV = binary (../) let NEG = unary (fun x -> -x) // ============================================== // ,     // ============================================== let SQUARE = DUP >> MUL let CUBE = DUP >> DUP >> MUL >> MUL let SUM_NUMBERS_UPTO = DUP // n >> ONE >> ADD // n+1 >> MUL // n(n+1) >> TWO >> SWAP >> DIV // n(n+1) / 2 

निष्कर्ष

हमारे पास एक साधारण स्टैक आधारित कैलकुलेटर है। हमने देखा कि कैसे, कुछ आदिम संचालन ( push , pop , binary , unary ) और अन्य के साथ शुरू करके, आप एक पूर्ण-निर्मित DSL का निर्माण कर सकते हैं, जिसे लागू करना और उपयोग करना आसान है।

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

मुझे एशले फेनियलो के भव्य ब्लॉग के इस लेख के लिए विचार मिला। यदि आप F # पर आधारित स्टैक-आधारित भाषा के अनुकरण में गहरा गोता लगाना चाहते हैं, तो इसके साथ शुरू करें। मजा आ गया!

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

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

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

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

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

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

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

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

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