🙃 😂 ➰ F # 8: भेदभाव रहित संघ 🎭 📤 ⛹🏽

इसलिए हमारी एफ # यात्रा जारी है। हमने कुछ बुनियादी प्रकार के बिल्डिंग ब्लॉकों को देखा, जैसे रिकॉर्ड्स / ट्यूपल्स, अब यह चिह्नित अप जॉन्स पर एक नज़र डालने का समय है।

लेबल किए गए यूनियन मूल्यों के लिए समर्थन प्रदान करते हैं, जो कई संभावित मूल्यों में से एक हो सकता है। संभावित मानों को "संयुक्त मामलों" के रूप में जाना जाता है, और नीचे दिखाए गए फ़ॉर्म को लें:

case-identifier1 [of [ fieldname1 : ] type1 [ * [ fieldname2 : ] type2 …]

चिंता न करें अगर यह वाक्यविन्यास भयभीत दिखता है, तो यह वास्तव में क्या घटता है एक लेबल की उपस्थिति है ताकि प्रत्येक मामले को दूसरों से पहचाना जा सके (प्रतिष्ठित), और संयोजन के मामले के लिए प्रकार। नाम के कुछ नियम हैं, जैसे कि

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

यहाँ एक खराब आईडी का उदाहरण दिया गया है

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

 type LabelUnionType = Int of int | String of string

बिल्डिंग टैग किए गए संघों

तो एकीकरण का मामला कैसे बनाया जाए? खैर, अलग-अलग तरीके हैं, आप निम्नलिखित तरीकों में से एक का उपयोग कर सकते हैं:

 let currentLabelUnionType1 = 13 printfn "let currentLabelUnionType1 = 13" printfn "%O" currentLabelUnionType1 let currentLabelUnionType2 = Int 23 printfn "let currentLabelUnionType2 = Int 23" printfn "%O" currentLabelUnionType2 printfn "%A" currentLabelUnionType2 let currentLabelUnionType3 = "Cat" printfn "let currentLabelUnionType3 = \"Cat\"" printfn "%O" currentLabelUnionType3 printfn "%A" currentLabelUnionType3 let currentLabelUnionType4 = String "Cat" printfn "let currentLabelUnionType4 = String \"Cat\"" printfn "%O" currentLabelUnionType4 printfn "%A" currentLabelUnionType4

जब प्रिंटफ़न फ़ंक्शन के माध्यम से लॉन्च किया जाता है, तो स्टार्टअप पर निम्नलिखित परिणाम दे सकते हैं (मैं नीचे% A या% O प्रिंटफ़न फ़ॉर्म का उपयोग करता हूं:

तुम बहुत मामलों के संयोजन में किसी भी प्रकार का उपयोग कर सकते हैं

गाड़ी
प्रलेखन
अन्य प्रकार

एकमात्र नियम यह है कि आपके यूनियन केस का उपयोग करने से पहले प्रकार को परिभाषित किया जाना चाहिए।

यहाँ एक उदाहरण है जो संघ के मामलों में एक तुच्छ प्रकार का उपयोग करता है:

 type unionUsingTuples = CCY of (int * String) | Rates of (int * decimal) ..... ..... let tupledUnion = (12, "GBP")

खाली यूनियनों

आप खाली यूनियनों का भी उपयोग कर सकते हैं। वे कौन से हैं जहाँ आप एक प्रकार निर्दिष्ट नहीं करते हैं। यह उन्हें मानक .NET गणना मूल्यों के समान अधिक बनाता है। यहाँ एक उदाहरण है:

 type Player = Cross | Nought .... .... let emptyUnion = Cross

प्रकार के समान मामलों के बारे में कैसे

ईगल आंख, आप की तरह, समस्या देख सकते हैं। अगर हमारे पास ऐसा कुछ होता तो क्या होता:

 type PurchaseOrders = Orders of (string * int) | Empty type ClientOrders = Orders of (string * int) | Empty

यह हमें समस्याएं पैदा कर रहा है, है ना। हम इस प्रकार के सीमांकित गठबंधनों के बीच अंतर कैसे करेंगे? सौभाग्य से, हम इसके लिए पूरी तरह से योग्य दृष्टिकोण ले सकते हैं, इसलिए हम बस कर सकते हैं, और सब कुछ उम्मीद के मुताबिक काम करेगा। यह ध्यान दिया जाना चाहिए कि आप इसे एक कदम आगे ले जा सकते हैं और मॉड्यूल का नाम शामिल कर सकते हैं यदि मॉड्यूल शामिल है (हम अगले लेख में इसके बारे में अधिक जानकारी प्राप्त करेंगे):

 let purchaseOrders = PurchaseOrders.Orders ("box of 100 scrubbing brushes", 1) let clientOrders = ClientOrders.Orders ("scrubbing brush", 23)

तुलना

कई एफ # प्रकारों के साथ, सीमांकित जोड़ समान माना जाता है यदि

उनके संयुक्त मामले की लंबाई समान है।
उनके संघ मामलों के प्रकार मेल खाते हैं।
संघ के उनके मामलों के मूल्य समान हैं।

न के बराबर

यहाँ एक उदाहरण है जहाँ समानता का सम्मान नहीं किया जाता है:

 let purchaseOrders1 = PurchaseOrders.Orders ("box of 100 scrubbing brushes", 1) let purchaseOrders2 = PurchaseOrders.Orders ("10 pack of disks", 1) printfn "purchaseOrders1 = purchaseOrders2 %A" (purchaseOrders1 = purchaseOrders2)

कर रहे हैं

यहाँ समानता का एक उदाहरण है। यह नियमित .NET कोड जैसा कुछ है, आप जानते हैं, यदि सदस्य समान हैं, उनके पास समान मान और उनकी सही संख्या है, तो यह लगभग समान है (यदि हम हैश कोड की उपेक्षा करते हैं):

 let purchaseOrders1 = PurchaseOrders.Orders ("box of 100 scrubbing brushes", 1) let purchaseOrders2 = PurchaseOrders.Orders ("box of 100 scrubbing brushes", 1) printfn "purchaseOrders1 = purchaseOrders2 %A" (purchaseOrders1 = purchaseOrders2)

यह ध्यान दिया जाना चाहिए कि जब हम अलग-अलग प्रकार के होते हैं, तो हम समानता का उपयोग नहीं कर सकते हैं क्योंकि वे विभिन्न प्रकार के हैं, इसलिए यह काम नहीं करेगा:

तुलना पैटर्न

नीचे एक छोटा कार्य है जो एक कार्ड यूनियन लेता है और उस यूनियन के मामलों को प्रदर्शित करता है जिसे इसके साथ बुलाया गया था, और केवल यूनिट (शून्य, यदि आपको इस श्रृंखला में पिछले लेखों से यह याद है) लौटाता है:

 type Card = ValueCard of int | Jack | Queen | King | Ace .... .... let cardFunction card = match card with | ValueCard i -> printfn "its a value card of %A" i | Jack -> printfn "its a Jack" | Queen -> printfn "its a Jack" | King -> printfn "its a Jack" | Ace -> printfn "its a Ace" () //return unit //shows you how to pass it in without a Let binding do cardFunction (Card.ValueCard 8) //or you could use explicit Let binding if you do desire let aceCard = Ace do cardFunction aceCard

तो वास्तव में पर्दे के पीछे क्या होता है

तो अब हमने कुछ उदाहरण देखे हैं कि कैसे लेबल वाले संघ कार्य करते हैं। तो, आपकी राय में, क्या हो सकता है अगर हमारे पास F # लाइब्रेरी है जो चिन्हित जोड़ का उपयोग करता है और हमने इसे C # / VB.NET से उपयोग करने का निर्णय लिया है। क्या आपको लगता है कि यह काम करेगा। जवाब: मुझे यकीन है कि यह होगा। मैं इंटरॉप के बारे में भविष्य में कहीं पर एक पूरी पोस्ट करूंगा, लेकिन मैंने अभी सोचा कि लेबल के जोड़ के लिए अभी इस पर कुछ विचार करना दिलचस्प हो सकता है, क्योंकि वे मानक .NET प्रोग्रामिंग में हम जो कुछ भी देखते हैं, उससे बहुत अलग हैं।

तो, आइए ऊपर कार्ड लें, जो यह कोड था:

 type Card = ValueCard of int | Jack | Queen | King | Ace

और इसे एक decompiler जैसे Reflector / DotPeek (आपके पास सभी) के माध्यम से चलाएं। मैंने DotPeek का उपयोग किया और इस C # कोड को इस एकल F # लाइन के लिए मिला। इसलिए, जैसा कि आप देख सकते हैं, F # कंपाइलर ने यह सुनिश्चित करने के लिए एक बढ़िया काम किया है कि F # प्रकार नियमित रूप से .NET के साथ अच्छी तरह से काम करेंगे, जैसे C # / VB.NET।

 using Microsoft.FSharp.Core; using System; using System.Collections; using System.Diagnostics; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; [CompilationMapping(SourceConstructFlags.Module)] public static class Program { [EntryPoint] public static int main(string[] argv) { return 0; } [DebuggerDisplay("{__DebugDisplay(),nq}")] [CompilationMapping(SourceConstructFlags.SumType)] [Serializable] [StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)] public class Card : IEquatable<Program.Card>, IStructuralEquatable, IComparable<Program.Card>, IComparable, IStructuralComparable { [CompilerGenerated] [DebuggerNonUserCode] [DebuggerBrowsable(DebuggerBrowsableState.Never)] public int Tag { [DebuggerNonUserCode] get { return this._tag; } } [CompilerGenerated] [DebuggerNonUserCode] [DebuggerBrowsable(DebuggerBrowsableState.Never)] public bool IsValueCard { [DebuggerNonUserCode] get { return this.get_Tag() == 0; } } [CompilerGenerated] [DebuggerNonUserCode] [DebuggerBrowsable(DebuggerBrowsableState.Never)] public static Program.Card Jack { [CompilationMapping(SourceConstructFlags.UnionCase, 1)] get { // ISSUE: reference to a compiler-generated field return Program.Card._unique_Jack; } } [CompilerGenerated] [DebuggerNonUserCode] [DebuggerBrowsable(DebuggerBrowsableState.Never)] public bool IsJack { [DebuggerNonUserCode] get { return this.get_Tag() == 1; } } [CompilerGenerated] [DebuggerNonUserCode] [DebuggerBrowsable(DebuggerBrowsableState.Never)] public static Program.Card Queen { [CompilationMapping(SourceConstructFlags.UnionCase, 2)] get { // ISSUE: reference to a compiler-generated field return Program.Card._unique_Queen; } } [CompilerGenerated] [DebuggerNonUserCode] [DebuggerBrowsable(DebuggerBrowsableState.Never)] public bool IsQueen { [DebuggerNonUserCode] get { return this.get_Tag() == 2; } } [CompilerGenerated] [DebuggerNonUserCode] [DebuggerBrowsable(DebuggerBrowsableState.Never)] public static Program.Card King { [CompilationMapping(SourceConstructFlags.UnionCase, 3)] get { // ISSUE: reference to a compiler-generated field return Program.Card._unique_King; } } [CompilerGenerated] [DebuggerNonUserCode] [DebuggerBrowsable(DebuggerBrowsableState.Never)] public bool IsKing { [DebuggerNonUserCode] get { return this.get_Tag() == 3; } } [CompilerGenerated] [DebuggerNonUserCode] [DebuggerBrowsable(DebuggerBrowsableState.Never)] public static Program.Card Ace { [CompilationMapping(SourceConstructFlags.UnionCase, 4)] get { // ISSUE: reference to a compiler-generated field return Program.Card._unique_Ace; } } [CompilerGenerated] [DebuggerNonUserCode] [DebuggerBrowsable(DebuggerBrowsableState.Never)] public bool IsAce { [DebuggerNonUserCode] get { return this.get_Tag() == 4; } } static Card() { } [CompilationMapping(SourceConstructFlags.UnionCase, 0)] public static Program.Card NewValueCard(int item) { return (Program.Card) new Program.Card.ValueCard(item); } [CompilationMapping(SourceConstructFlags.UnionCase, 1)] public static Program.Card get_Jack() { // ISSUE: reference to a compiler-generated field return Program.Card._unique_Jack; } [CompilationMapping(SourceConstructFlags.UnionCase, 2)] public static Program.Card get_Queen() { // ISSUE: reference to a compiler-generated field return Program.Card._unique_Queen; } [CompilationMapping(SourceConstructFlags.UnionCase, 3)] public static Program.Card get_King() { // ISSUE: reference to a compiler-generated field return Program.Card._unique_King; } [CompilationMapping(SourceConstructFlags.UnionCase, 4)] public static Program.Card get_Ace() { // ISSUE: reference to a compiler-generated field return Program.Card._unique_Ace; } public static class Tags { public const int ValueCard = 0; public const int Jack = 1; public const int Queen = 2; public const int King = 3; public const int Ace = 4; } [DebuggerTypeProxy(typeof (Program.Card.ValueCard\u0040DebugTypeProxy))] [DebuggerDisplay("{__DebugDisplay(),nq}")] [Serializable] [SpecialName] public class ValueCard : Program.Card { [CompilationMapping(SourceConstructFlags.Field, 0, 0)] [CompilerGenerated] [DebuggerNonUserCode] public int Item { [DebuggerNonUserCode] get { return this.item; } } } [SpecialName] internal class ValueCard\u0040DebugTypeProxy { [CompilationMapping(SourceConstructFlags.Field, 0, 0)] [CompilerGenerated] [DebuggerNonUserCode] public int Item { [DebuggerNonUserCode] get { return this._obj.item; } } } } }

पुनरावर्ती मामले (वृक्ष संरचनाएं)

लेबल किए गए जोड़ का उपयोग पुनरावर्ती तरीके से भी किया जा सकता है, जहां संघ स्वयं को एक या अधिक मामलों में एक प्रकार के रूप में इस्तेमाल किया जा सकता है। यह चिह्नित पेड़ों की संरचना के लिए बहुत उपयुक्त है, जैसे कि:

गणित के भाव
सार सिंटेक्स के पेड़
Xml

वास्तव में, MSDN के कुछ अच्छे उदाहरण हैं।

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

नीचे दिए गए उदाहरण में myTree के लिए पेड़ की संरचना नीचे दी गई है:

और यह है कि हम कैसे चिह्नित जोड़ का उपयोग करके माईट्री को मॉडल कर सकते हैं ध्यान दें कि हम चिह्नित मामलों में शामिल होने के मामलों में से एक को कैसे वर्गीकृत करते हैं। इस मामले में, या तो संयोजन के मामले

टिप (खाली यूनियन, .NET में मानक गणना के रूप में कार्य करता है)
या एक नंबर, ट्री, ट्री से 3 अंकों का टपल

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

लेकिन हम अच्छे लोग हैं, और हम अपने उपयोग के मामले का समर्थन करने के लिए सही कीवर्ड का उपयोग करेंगे, इसलिए हम जारी रखते हैं

 type Tree = | Tip | Node of int * Tree * Tree .... .... .... .... let rec sumTree tree = match tree with | Tip -> 0 | Node(value, left, right) -> value + sumTree(left) + sumTree(right) let myTree = Node(0, Node(1, Node(2, Tip, Tip), Node(3, Tip, Tip)), Node(4, Tip, Tip)) let resultSumTree = sumTree myTree printfn "Value of sumTree is %A" resultSumTree

MSDN का एक और अच्छा उदाहरण है कि मुझे लगता है कि यह चोरी करने के लायक होगा (हाँ, मैं अब इसके बारे में खुलकर बात कर रहा हूं। मुझे लगता है कि जब आप लोग / लड़कियां इस उधार उदाहरण से कुछ निकाल रहे हैं, जैसे कि मैं स्पष्ट रूप से कहता हूं, मैं उधार हूं, मैं व्यवसाय में नहीं हूं)। आइए इस उदाहरण को यहां देखें:

 type Expression = | Number of int | Add of Expression * Expression | Multiply of Expression * Expression | Variable of string .... .... .... let rec Evaluate (env:Map<string,int>) exp = match exp with | Number n -> n | Add (x, y) -> Evaluate env x + Evaluate env y | Multiply (x, y) -> Evaluate env x * Evaluate env y | Variable id -> env.[id] let environment = Map.ofList [ "a", 1 ; "b", 2 ; "c", 3 ] // Create an expression tree that represents // the expression: a + 2 * b. let expressionTree1 = Add(Variable "a", Multiply(Number 2, Variable "b")) // Evaluate the expression a + 2 * b, given the // table of values for the variables. let result = Evaluate environment expressionTree1 printfn "Value of sumTree is %A" result

F # 8: भेदभाव रहित संघ