कार्यात्मक प्रोग्रामिंग पर लेखों की एक श्रृंखला के तीसरे भाग ने खींच लिया है। आज हम इस प्रतिमान के सभी प्रकारों के बारे में बात करेंगे और उनके उपयोग के उदाहरण दिखाएंगे। आदिम प्रकार के बारे में अधिक जानकारी, सामान्यीकृत प्रकार और बहुत अधिक कटौती के तहत!

अब जब हमें फ़ंक्शन की कुछ समझ है, तो हम देखेंगे कि डोमेन और रेंज जैसे फ़ंक्शंस के साथ कैसे इंटरैक्ट करते हैं। यह लेख सिर्फ एक समीक्षा है। प्रकारों में गहन विसर्जन के लिए "एफ # प्रकार समझने" की एक श्रृंखला है।

आरंभ करने के लिए, हमें टाइप नोटेशन की थोड़ी बेहतर समझ होनी चाहिए। हमने डोमेन और रेंज को अलग करते हुए तीर संकेतन " -> " को देखा। तो फ़ंक्शन हस्ताक्षर हमेशा इस तरह दिखता है:

 val functionName : domain -> range

कार्यों के कुछ और उदाहरण:

 let intToString x = sprintf "x is %i" x //  int  string let stringToInt x = System.Int32.Parse(x)

यदि आप एक इंटरैक्टिव विंडो में इस कोड को निष्पादित करते हैं , तो आप निम्नलिखित हस्ताक्षर देख सकते हैं:

 val intToString : int -> string val stringToInt : string -> int

उनका मतलब है:

intToString में int का एक डोमेन होता है, जो टाइप string की सीमा तक मैप string ।
stringToInt में एक प्रकार का string का एक डोमेन होता है, जो कई प्रकार के int पर मैप करता है।

आदिम प्रकार

अपेक्षित आदिम प्रकार हैं: स्ट्रिंग, इंट, फ्लोट, बूल, चार, बाइट, आदि, साथ ही साथ .NET प्रकार प्रणाली के कई अन्य डेरिवेटिव।

आदिम प्रकार के कार्यों के कुछ उदाहरण

 let intToFloat x = float x // "float" -  int  float let intToBool x = (x = 2) // true  x  2 let stringToString x = x + " world"

और उनके हस्ताक्षर:

 val intToFloat : int -> float val intToBool : int -> bool val stringToString : string -> string

टाइप एनोटेशन

पिछले उदाहरणों में, एफ # संकलक ने मापदंडों और परिणामों के प्रकारों को सही ढंग से परिभाषित किया है। लेकिन हमेशा ऐसा नहीं होता है। यदि आप निम्नलिखित कोड निष्पादित करने का प्रयास करते हैं, तो आपको एक संकलन त्रुटि मिलेगी:

 let stringLength x = x.Length => error FS0072: Lookup on object of indeterminate type

संकलक तर्क "x" के प्रकार को नहीं जानता है, और इस वजह से, यह नहीं जानता कि "लंबाई" एक वैध विधि है या नहीं। ज्यादातर मामलों में, यह F # कंपाइलर को "टाइप एनोटेशन" पास करके तय किया जा सकता है। तब उसे पता चलेगा कि किस प्रकार का उपयोग करना है। निश्चित संस्करण में, हम संकेत देते हैं कि टाइप "x" स्ट्रिंग है।

 let stringLength (x:string) = x.Length

x:string चारों ओर ब्रेसिज़ x:string पैरामीटर महत्वपूर्ण हैं। यदि उन्हें छोड़ दिया जाता है, तो संकलक तय करेगा कि स्ट्रिंग वापसी मूल्य है! अर्थात्, एक ओपन कोलोन का उपयोग रिटर्न वैल्यू के प्रकार को इंगित करने के लिए किया जाता है, जैसा कि निम्नलिखित उदाहरण में दिखाया गया है।

 let stringLengthAsInt (x:string) :int = x.Length

हम संकेत देते हैं कि पैरामीटर x एक स्ट्रिंग है, और रिटर्न मान एक पूर्णांक है।

पैरामीटर के रूप में प्रकार

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

फ़ंक्शन evalWith5ThenAdd2 पर विचार करें, जो एक फ़ंक्शन को पैरामीटर के रूप में लेता है, और फिर 5 से इस फ़ंक्शन की गणना करता है और परिणाम में 2 जोड़ता है:

 let evalWith5ThenAdd2 fn = fn 5 + 2 //   ,   fn(5) + 2

इस फ़ंक्शन का हस्ताक्षर इस तरह दिखता है:

 val evalWith5ThenAdd2 : (int -> int) -> int

आप देख सकते हैं कि डोमेन (int->int) और रेंज int । इसका क्या मतलब है? इसका मतलब है कि इनपुट पैरामीटर एक साधारण मूल्य नहीं है, लेकिन कई फ़ंक्शन से लेकर int तक एक फ़ंक्शन है। आउटपुट मान एक फ़ंक्शन नहीं है, लेकिन सिर्फ एक int ।

आइए कोशिश करते हैं:

 let add1 x = x + 1 //  -  (int -> int) evalWith5ThenAdd2 add1 //

और:

 val add1 : int -> int val it : int = 8

" add1 " एक ऐसा फंक्शन है जो int से int मैप करता है, जैसा कि हम हस्ताक्षर से देखते हैं। यह evalWith5ThenAdd2 लिए एक वैध पैरामीटर है, और इसका परिणाम 8 है।

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

एक और मामला:

 let times3 x = x * 3 // -  (int -> int) evalWith5ThenAdd2 times3 //

यह प्रदान करता है:

 val times3 : int -> int val it : int = 17

" times3 " भी एक फ़ंक्शन है जो int से int मैप करता है, जैसा कि हस्ताक्षर से देखा जा सकता है। यह evalWith5ThenAdd2 लिए एक मान्य पैरामीटर भी है। गणनाओं का परिणाम 17 है।

कृपया ध्यान दें कि इनपुट डेटा संवेदनशील है। यदि फ़ंक्शन पारित हो गया है, तो float का उपयोग करता है, int नहीं, तो कुछ भी काम नहीं करेगा। उदाहरण के लिए, यदि हमारे पास:

 let times3float x = x * 3.0 // -  (float->float) evalWith5ThenAdd2 times3float

संकलक, जब संकलन करने की कोशिश कर रहा है, एक त्रुटि लौटेगा:

 error FS0001: Type mismatch. Expecting a int -> int but given a float -> float

यह रिपोर्ट करते हुए कि इनपुट फ़ंक्शन को int->int प्रकार का कार्य होना चाहिए।

आउटपुट के रूप में कार्य

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

 let adderGenerator numberToAdd = (+) numberToAdd

उसके हस्ताक्षर:

 val adderGenerator : int -> (int -> int)

इसका मतलब है कि जनरेटर एक int लेता है और एक फ़ंक्शन ("योजक") बनाता है जो कि ints को मैप करता है। आइए देखें कि यह कैसे काम करता है:

 let add1 = adderGenerator 1 let add2 = adderGenerator 2

दो योजक कार्य बनाए जाते हैं। पहला एक फ़ंक्शन बनाता है जो इनपुट में 1 जोड़ता है, दूसरा जोड़ता है 2. ध्यान दें कि हस्ताक्षर बिल्कुल वही हैं जो हम उम्मीद करते थे।

 val add1 : (int -> int) val add2 : (int -> int)

अब आप हमेशा की तरह उत्पन्न कार्यों का उपयोग कर सकते हैं, वे स्पष्ट रूप से परिभाषित कार्यों से अलग नहीं हैं:

 add1 5 // val it : int = 6 add2 5 // val it : int = 7

फ़ंक्शन प्रकारों को प्रतिबंधित करने के लिए प्रकार एनोटेशन का उपयोग करना

पहले उदाहरण में, हमने एक फ़ंक्शन को देखा:

 let evalWith5ThenAdd2 fn = fn 5 +2 > val evalWith5ThenAdd2 : (int -> int) -> int

इस उदाहरण में, F # यह निष्कर्ष निकाल सकता है कि " fn " int को int रूपांतरित करता है, इसलिए इसका हस्ताक्षर int->int ।

लेकिन निम्नलिखित मामले में "fn" का हस्ताक्षर क्या है?

 let evalWith5 fn = fn 5

यह स्पष्ट है कि " fn " एक प्रकार का फ़ंक्शन है जो एक int लेता है, लेकिन यह क्या लौटाता है? संकलक इस प्रश्न का उत्तर नहीं दे सकता है। ऐसे मामलों में, यदि फ़ंक्शन के प्रकार को इंगित करना आवश्यक हो जाता है, तो आप फ़ंक्शन मापदंडों के साथ-साथ आदिम प्रकारों के लिए एनोटेशन प्रकार जोड़ सकते हैं।

 let evalWith5AsInt (fn:int->int) = fn 5 let evalWith5AsFloat (fn:int->float) = fn 5

इसके अलावा, आप रिटर्न प्रकार निर्धारित कर सकते हैं।

 let evalWith5AsString fn :string = fn 5

क्योंकि मुख्य फ़ंक्शन रिटर्न string , फ़ंक्शन " fn " भी string वापस करने के लिए मजबूर है। इस प्रकार, " fn " प्रकार को स्पष्ट रूप से निर्दिष्ट करना आवश्यक नहीं है।

"यूनिट" टाइप करें

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

 let printInt x = printf "x is %i" x //

उसके हस्ताक्षर क्या हैं?

 val printInt : int -> unit

एक " unit " क्या है?

भले ही फ़ंक्शन मानों को वापस नहीं करता है, फिर भी उसे रेंज की आवश्यकता है। गणित की दुनिया में कोई "शून्य" कार्य नहीं हैं। प्रत्येक फ़ंक्शन को कुछ वापस करना होगा, क्योंकि फ़ंक्शन एक मैपिंग है, और मैपिंग को कुछ प्रदर्शित करना होगा!

तो, F # में, इस तरह के फ़ंक्शन एक विशेष प्रकार के परिणाम लौटाते हैं, जिन्हें " unit " कहा जाता है। इसमें केवल एक मान होता है, जिसे " () " द्वारा चिह्नित किया जाता है। आप सोच सकते हैं कि unit और () क्रमशः सी # से "शून्य" और "नल" की तरह हैं। लेकिन उनके विपरीत, unit वास्तविक प्रकार है, और () वास्तविक मूल्य है। इसे सत्यापित करने के लिए, बस करें:

 let whatIsThis = ()

निम्नलिखित हस्ताक्षर प्राप्त होंगे:

 val whatIsThis : unit = ()

जो इंगित करता है कि लेबल " whatIsThis " प्रकार की unit और एक मूल्य () साथ जुड़ा हुआ है।

अब, " printInt " हस्ताक्षर पर printInt , हम इस प्रविष्टि के अर्थ को समझ सकते हैं:

 val printInt : int -> unit

यह हस्ताक्षर कहता है कि printInt में int का एक डोमेन है, जो कुछ ऐसी चीज़ों में अनुवाद करता है जो हमें रूचि नहीं देता है।

मापदंडों के बिना कार्य

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

 let printHello = printf "hello world" //

परिणाम:

 hello world val printHello : unit = ()

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

 val aName: type = constant

इस उदाहरण में, हम देखते हैं कि printHello वास्तव में एक साधारण मूल्य () । यह एक फ़ंक्शन नहीं है जिसे हम बाद में कॉल कर सकते हैं।

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

आप बिना किसी पैरामीटर के, unit तर्क के लिए परिभाषा को बाध्य करते हुए एक वास्तविक पुन: प्रयोज्य कार्य बना सकते हैं:

 let printHelloFn () = printf "hello world" //

अब उसका हस्ताक्षर बराबर है:

 val printHelloFn : unit -> unit

और इसे कॉल करने के लिए, हमें एक पैरामीटर के रूप में () पास करना होगा:

 printHelloFn ()

अनदेखा फ़ंक्शन के साथ इकाई प्रकारों को मजबूत करना

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

 do 1+1 // => FS0020: This expression should have type 'unit' let something = 2+2 // => FS0020: This expression should have type 'unit' "hello"

इन स्थितियों में मदद करने के लिए, एक विशेष ignore फ़ंक्शन है जो कुछ भी लेता है और रिटर्न unit । इस कोड का सही संस्करण यह हो सकता है:

 do (1+1 |> ignore) // ok let something = 2+2 |> ignore // ok "hello"

सामान्य प्रकार

ज्यादातर मामलों में, यदि फ़ंक्शन पैरामीटर का प्रकार किसी भी प्रकार का हो सकता है, तो हमें इसके बारे में कुछ कहने की आवश्यकता है। F # ऐसी स्थितियों के लिए .NET जेनरिक का उपयोग करता है।

उदाहरण के लिए, निम्न फ़ंक्शन कुछ पाठ जोड़कर एक पैरामीटर को स्ट्रिंग में परिवर्तित करता है:

 let onAStick x = x.ToString() + " on a stick"

कोई फर्क नहीं पड़ता कि किस प्रकार का पैरामीटर है, सभी ऑब्जेक्ट ToString() में कर सकते हैं।

हस्ताक्षर:

 val onAStick : 'a -> string

किस प्रकार का 'a ? एफ # में, यह एक सामान्य प्रकार को इंगित करने का एक तरीका है जो संकलन के समय अज्ञात है। "ए" से पहले एक एपोस्ट्रोफ का अर्थ है कि प्रकार सामान्य है। C # में इस हस्ताक्षर के बराबर:

 string onAStick<a>(); //   string OnAStick<TObject>(); // F#-   'a    // C#'-   "TObject"

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

उसी फ़ंक्शन का उपयोग int , float और string लिए किया जाता है।

 onAStick 22 onAStick 3.14159 onAStick "hello"

यदि दो सामान्यीकृत पैरामीटर हैं, तो संकलक उन्हें दो अलग-अलग नाम देगा: 'a पहले के लिए, दूसरे के लिए 'b आदि। उदाहरण के लिए:

 let concatString xy = x.ToString() + y.ToString()

इस हस्ताक्षर में दो सामान्य प्रकार होंगे: 'a और 'b :

 val concatString : 'a -> 'b -> string

दूसरी ओर, कंपाइलर पहचानता है जब केवल एक सामान्य प्रकार की आवश्यकता होती है। निम्नलिखित उदाहरण में, x और y एक ही प्रकार के होने चाहिए:

 let isEqual xy = (x=y)

इसलिए, एक फ़ंक्शन हस्ताक्षर में दोनों मापदंडों के लिए एक ही सामान्य प्रकार है:

 val isEqual : 'a -> 'a -> bool

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

अन्य प्रकार

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

Tuples (tuples)। यह एक जोड़ी है, एक ट्रिपल, आदि, जो अन्य प्रकारों से बना है। उदाहरण के लिए, ("hello", 1) एक टपल है जो string और int पर आधारित है। एक अल्पविराम ट्यूलिप की एक बानगी है; यदि एक अल्पविराम कहीं एफ # में देखा जाता है, तो यह लगभग टपल का हिस्सा होने की गारंटी है।
फ़ंक्शन हस्ताक्षरों में, टुपल्स को शामिल दो प्रकारों के "उत्पादों" के रूप में लिखा जाता है। इस मामले में, टपल प्रकार का होगा:

 string * int // ("hello", 1)

संग्रह । सबसे आम हैं सूची (सूची), seq (अनुक्रम) और सरणी। सूचियाँ और सरणियाँ आकार में तय की गई हैं, जबकि अनुक्रम संभावित रूप से अनंत हैं (दृश्यों के पीछे, अनुक्रम समान IEnumrable )। फ़ंक्शन हस्ताक्षरों में, उनके पास अपने कीवर्ड हैं: " list ", " seq " और सरणियों के लिए " [] "।

 int list // List type  [1;2;3] string list // List type  ["a";"b";"c"] seq<int> // Seq type  seq{1..10} int [] // Array type  [|1;2;3|]

विकल्प (वैकल्पिक प्रकार) । यह वस्तुओं पर एक साधारण आवरण है जो गायब हो सकता है। दो विकल्प हैं: Some (जब मूल्य मौजूद है) और None (जब मूल्य नहीं होता है)। फ़ंक्शन हस्ताक्षरों में, उनका अपना कीवर्ड " option " है:

 int option // Some 1

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

अपने प्रकार की समझ का परीक्षण करें

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

 let testA = float 2 let testB x = float 2 let testC x = float 2 + x let testD x = x.ToString().Length let testE (x:float) = x.ToString().Length let testF x = printfn "%s" x let testG x = printfn "%f" x let testH = 2 * 2 |> ignore let testI x = 2 * 2 |> ignore let testJ (x:int) = 2 * 2 |> ignore let testK = "hello" let testL() = "hello" let testM x = x=x let testN x = x 1 // :     x? let testO x:string = x 1 // :    :string ?

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

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

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

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

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

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

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

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

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