एफ # का परिचय, नीली गोली

[ पिछला पोस्ट ]

परिचय

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

विसर्जन

शुरुआत करने के लिए, मैं एफपी की उत्पत्ति के बारे में बात करना चाहूंगा, λ-पथरी। आखिरकार, यह अलोंजो चर्च द्वारा बनाया गया यह गणितीय सिद्धांत था जिसने कार्यात्मक प्रोग्रामिंग की नींव रखी। मैं गणित पर एक लंबा और थकाऊ व्याख्यान नहीं दूंगा, मैं बस आपको संक्षेप में बताऊंगा। अंत में, फिर किसी को अपने ज्ञान से आश्चर्यचकित करना संभव होगा, न केवल एफ # में, बल्कि इसकी गणितीय पृष्ठभूमि में भी। क्या, वास्तव में, λ-पथरी के लिए यह भयानक नाम है? वह चर्च गणित को सामान्य बनाना चाहता था ताकि मौलिक अवधारणाओं - कार्यों में से एक के रूप में पूरी तरह से प्रतिनिधित्व किया जा सके। इसके अलावा, उनका सिद्धांत बताता है कि सब कुछ एक फ़ंक्शन है। “क्या समस्या है? फ़ंक्शन की मौजूदा अवधारणा का उपयोग क्यों नहीं किया गया? ”पाठक पूछेगा। तथ्य यह है कि गणितज्ञ हर जगह और हर जगह कार्यों का उपयोग करना चाहता था, और, अक्सर, वे एक नाम देने में सहज नहीं होते हैं, जैसा कि हम सभी स्कूलों / संस्थानों में सिखाया जाता था:
f(x) = x - 5
f(6) = 6 - 5 = 1

तब अलोंजो एक संकेतन के साथ आया, जो आपको एक फ़ंक्शन को नाम दिए बिना लिखने की अनुमति देता है:
λx.x-5

इस मामले में, फ़ंक्शन पिछले उदाहरण के लिए बिल्कुल समान है, सिवाय इसके कि इसका कोई नाम नहीं है। वह तर्क के मूल्य को उसी तरह से पारित कर सकता है:
(λx.x - 5) 6 = 6 - 5 = 1

एक और λ-function को λ-function के मापदंडों में स्थानांतरित करना भी संभव है। मुझे लगता है कि हम पिछले लेख में मिले लंबो कार्यों के साथ प्रत्यक्ष सादृश्य स्पष्ट रूप से दिखाई दे रहे हैं।

“बकवास करना बंद करो! अधिक कोड। ”

और मैं लगभग गणित के साथ कर रहा हूँ। लगभग। आखिरकार, हर कोई जानता है कि पुनरावृत्ति क्या है? यह अच्छा है। अब हम फाइबोनैचि संख्याओं की गणना करने के लिए एक पुनरावर्ती फ़ंक्शन (स्वयं को कॉल करके) लिखेंगे। फाइबोनैचि संख्याएँ - संख्याओं का एक क्रम, जहाँ प्रत्येक बाद की संख्या पिछले वाले के योग के बराबर होती है:
Fib = {0, 1, 1, 2, 3, 5, 8, ...}

यदि आप इसे फ़ंक्शन की भाषा में लिखते हैं, तो फ़िबोनाकी संख्या को अनुक्रम में इसकी संख्या से लौटाने वाला फ़ंक्शन इस तरह दिखाई देगा:
f(n) = f(n - 1) + f(n - 2)
f(1) = 1
f(2) = 1

और इस तरह F # पर:

 let rec fib n = match n with | 1 | 2 -> 1 | n -> fib(n-1) + fib(n-2) 

यहां विचार करने के लिए दो नए कीवर्ड हैं:

• rec - इंगित करता है कि फ़ंक्शन पुनरावर्ती है
• मैच, एक पैटर्न मिलान तंत्र है, C # या C / C ++ पैटर्न से परिचित लोगों के लिए, जिन्हें स्टेरॉयड पर स्विच के रूप में दर्शाया जा सकता है।

एक फंक्शन के अंदर क्या होता है? वास्तव में, सब कुछ बहुत सरल है: यदि तर्क n 1 या 2 है, तो हम 1 वापस करते हैं, अन्यथा हम अनुक्रम में दो पिछली संख्याओं का योग लौटाते हैं। वास्तव में, मैच बहुत अधिक संभावनाएं प्रदान करता है, लेकिन हम इसे थोड़ी देर बाद वापस करेंगे, और एक शुरुआत के लिए हम एफ # में मुख्य प्रकारों पर विचार करेंगे।

प्रकार की घोषणा

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

 type myInt = int 

tuples

Tuple, या Tuple, F # में किसी प्रकार का मिश्रित प्रकार है। क्या और कैसे जल्दी से समझने के लिए, उदाहरणों पर विचार करें:

 //  int*int;    * -   let point2d = (10, 5) //  int*int*int let point3d = (1, 1, 2) //  string*int let personAndId = ("Some Name", 3) let x2d = fst point2d let y2d = snd point2d 

जैसा कि आप उदाहरण से देख सकते हैं, एक टपल दो या दो से अधिक प्रकारों का संयोजन है (नाम नहीं, लेकिन आदेश दिया गया है)। पॉइंट 2 डी और पॉइंट 3 डी 2-आयामी और 3-आयामी विमानों, व्यक्तिएंडआईड - नाम और आईडी पर बिंदुओं का प्रतिनिधित्व करते हैं। ट्यूपल्स के साथ काम करने की सुविधा के लिए, एफ # मानक लाइब्रेरी के दो कार्य हैं: एफएसटी और एसएनडी, जो क्रमशः टपल के पहले और दूसरे तत्व को वापस करते हैं। तीसरा आइटम कैसे प्राप्त करें?

 //     ; _ ,      /   let third (_, _, t) = t 

यहाँ एक टपल प्रकार की घोषणा का एक उदाहरण है:

 //  -;     string,  int type personAndId = string*int //    personAndId;    :     ,    let person:personAndId = ("Habr", 1) 

रिकॉर्ड उर्फ ​​रिकॉर्ड

बेशक, यह रिकॉर्ड के बारे में नहीं होगा। रिकॉर्ड एफ # की एक और संरचनात्मक इकाई है। वे tuples से अलग हैं कि रिकॉर्ड के प्रत्येक क्षेत्र में एक नाम है, सामग्री अभी भी कोई भी हो सकती है। वाक्य रचना पर विचार करें:

 type person = {name : string; surname : string; id : int} let sampleUser = {name = "Habra"; surname = "Habr"; id = 1} let sampleUserName = sampleUser.name 

मुझे लगता है कि किसी स्पष्टीकरण की आवश्यकता नहीं है।

विभेदित संघ, या टैग किए गए संघ

अगली संरचनात्मक इकाई संघ है। वे आपको विभिन्न तरीकों से डेटा को संयोजित करने की अनुमति देते हैं। यहाँ एक सरल जोड़ का एक उदाहरण दिया गया है:

 type Currency = | Liter of float | Pint of float let liter = Liter 5.0 let pint = Pint 10.0 

पैटर्न मिलान, या पैटर्न मिलान

अब जब पाठक पहले से ही एफ # की बुनियादी संरचनात्मक इकाइयों के बारे में बहुत कुछ जानता है, तो हम पैटर्न मिलान के बारे में अधिक विस्तार से बात कर सकते हैं। मैच कुछ हद तक अनिवार्य और OO भाषाओं के स्विच के समान है, केवल यह बहुत व्यापक संभावनाएं प्रदान करता है। केवल सीमा यह है कि टेम्पलेट्स को संभावित मूल्यों की पूरी श्रृंखला को कवर करना चाहिए। मैं यह नोट करना चाहता हूं कि यह केवल पहली बार में असुविधाजनक और बेतुका लगता है।

 // ,    let isOdd n = (n % 2 = 1) // ,    1  3    let oneToThree n = match n with | 1 -> printfn "One" | 2 -> printfn "Two" | 3 -> printfn "Three" //       ;      _  n | n -> printfn "Geather than three" //   type Point = int * int //  matching'   let findZero point = match point with | (0, 0) -> printfn "x = 0 and y = 0" | (0, y) -> printfn "(0, %d)" y | (x, 0) -> printfn "(%d, 0)" x | _ -> printfn "x <> 0 and y <> 0" type Person = | NameOnly of string | IdOnly of int //       -  | IdAndName of string * int //  matching'   let personInfo person = match person with | NameOnly(name) -> printf "Name is %s" name | IdOnly(id) -> printf "Id is %d" id | IdAndName(name, id) -> printf "Name is %s and Id is %d?" name id //  matching'a    let matchWithCondition x = match x with | x when x >= 5. && x <= 10. -> printfn "x is between 5.0 and 10.0" | _ -> () 

एक अधिक संपूर्ण विवरण यहां पाया जा सकता है ।

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

मान लें कि हमें एक द्विआधारी वृक्ष के कार्यान्वयन की आवश्यकता है जिसमें एक प्रकार है, अर्थात्, तार का एक पेड़, किलों का एक पेड़, आदि। एफ # में प्रकारों को सामान्यीकृत किया जा सकता है, यह इस तरह से किया जाता है:

 //     '    type 'a BinaryTree = //         , - | Node of 'a BinaryTree * 'a BinaryTree | Value of 'a (*         : type BinaryTree<'a> = | Node of BinaryTree<'a> * BinaryTree<'a> | Value of 'a *) //  ,       ,      let tree1 = Node( Node (Value 1, Value 2), Node (Value 5, Value 100) ) let tree2 = Node( Node (Value "Binary tree", Value "in F#"), Node (Value "is so", Value "Simple") ) 

हाँ, F # पर सामान्यीकृत बाइनरी ट्री ऐसा ही दिखता है।

निष्कर्ष

खैर मैं क्या कह सकता हूं, मुझे उम्मीद है कि मैंने व्यर्थ की कोशिश नहीं की है और कई लोग इस पोस्ट को भी पसंद करेंगे। अगली बार, हम नीली गोलियों को निगलते रहेंगे, सूचियों और अनुक्रमों, करी कार्यों और बहुत कुछ के बारे में बात करेंगे। पढ़ने के लिए धन्यवाद।

क्या पढ़ना है?

सबसे पहले, msdn , वहाँ आप आज के बारे में बात की गई का अधिक विस्तृत विवरण पा सकते हैं।
वास्तविक दुनिया के लिए दूसरा, कार्यात्मक प्रोग्रामिंग (टॉमस पेट्रिसक, जॉन स्कीट) उन लोगों के लिए एक पुस्तक है, जिन्हें समस्याओं को हल करने के लिए अनिवार्य दृष्टिकोण के लिए उपयोग किया जाता है। इस पद के कई उदाहरण आंशिक रूप से वहां से लिए गए थे।

उनके लिए जो कम थे

फाइबोनैचि

वास्तव में, ऊपर दिए गए पोस्ट में जो कोड दिया गया था वह भयानक है। लेकिन फिर इसे समझना आसान है। और जो लोग एक अधिक कार्यात्मक दृष्टिकोण देखना चाहते हैं, उनके लिए मैं एक अधिक सक्षम उदाहरण दूंगा (धन्यवाद, ओनिकियुका )

 let fib = Seq.unfold (fun state ->Some(fst state + snd state, (snd state, fst state + snd state))) (1,1) fib |> Seq.take 20 

जैसा कि ऊपर उल्लेख किया गया है, अधिक विस्तार से हम अगली बार ऐसे कार्यों का विश्लेषण करेंगे।

पैटर्न मिलान

भाव व्यक्त करें

 let second (x, y) = y let getValueFromOption (Some value) = value 

एक पैटर्न मिलान तंत्र का भी प्रतिनिधित्व करते हैं। धन्यवाद jack128 और onikiychuka ।