बीजगणितीय डेटा प्रकारों के उपयोग क्या हैं?

Question

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

---

संपादित करें: मैं नहीं पूछ रहा हूँ कि एक डेवलपर ADT के साथ क्या कर सकता है जो वस्तुओं के साथ नहीं किया जा सकता है। मैं पूछ रहा हूं कि क्या अन्य ऑपरेशन हैं जो एडीटी की अनुमति देते हैं; उदाहरण के लिए, क्या कोई अतिरिक्त प्रकार के बारे में तर्क कर सकता है यदि ADT कार्यरत हैं? क्या ADT किसी प्रकार के विश्लेषण की सुविधा देता है जो उनके बिना संभव नहीं होगा?

Comments

कॉलिंग विधियों को छोड़कर आप वस्तुओं के साथ क्या कर सकते हैं?

ADT वास्तव में "अमूर्त डेटा प्रकार" को संदर्भित करता है, न कि बीजीय डेटा प्रकार।

— री हेन हेनरिक्स

@ संदर्भ: यह संदर्भ के आधार पर या तो संदर्भित कर सकता है।

— sepp2k

@ रीन: यह वास्तव में करता है (जो मुझे ईमानदार होने के लिए काफी आश्चर्यजनक लगता है): हालांकि एडीटी के लिए विकिपीडिया लेख सार डेटा प्रकार और बीजीय डेटा प्रकार दोनों को संभावित अर्थों के रूप में सूचीबद्ध करता है। और ADT को सामान्यतः बीजीय डेटा प्रकारों के लिए संक्षिप्त नाम के रूप में उपयोग किया जाता है, उदाहरण के लिए हास्केल मेलिंग सूची और आईआरसी चैनल।

— sepp2k

@ राइन, मुझे पता है - बस "बीजगणितीय डेटा प्रकार" टाइप करने पर थक गया और मुझे लगा कि लोग यह समझने में सक्षम होंगे कि मैं किस संदर्भ को संदर्भित कर रहा था।

— ओनोरियो कैटेनेशिआ

Answer 1

बीजगणितीय डेटा प्रकार इस बात में भिन्न हैं कि उनका निर्माण कई प्रकार की "चीजों" से किया जा सकता है। उदाहरण के लिए, ट्री में कुछ भी नहीं (खाली), पत्ती या एक नोड हो सकता है।

data Tree = Empty
          | Leaf Int
          | Node Tree Tree

चूंकि एक नोड दो पेड़ों से बना होता है, इसलिए बीजीय डेटा प्रकार पुनरावर्ती हो सकते हैं।

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

depth :: Tree -> Int
depth Empty = 0
depth (Leaf n) = 1
depth (Node l r) = 1 + max (depth l) (depth r)

की तुलना में:

switch on (data.constructor)
  case Empty:
    return 0
  case Leaf:
    return 1
  case Node:
    let l = data.field1
    let r = data.field2
    return 1 + max (depth l) (depth r)

इसका नुकसान यह है कि प्रोग्रामर को लीफ से पहले खाली करने के लिए याद रखना चाहिए ताकि फ़ील्ड 1 किसी खाली पेड़ पर न पहुँच सके। इसी तरह, लीफ केस को नोड केस से पहले घोषित किया जाना चाहिए ताकि फील्ड 2 को लीफ पर एक्सेस नहीं किया जा सके। इस प्रकार प्रकार सुरक्षा भाषा द्वारा बनाए नहीं रखी जाती है, बल्कि प्रोग्रामर पर अतिरिक्त संज्ञानात्मक भार डालती है। वैसे, मैं इन उदाहरणों को सीधे विकिपीडिया पृष्ठों से पकड़ रहा हूं।

बेशक, एक डक-टाइपिंग लैन्गॉज़ कुछ ऐसा कर सकता है:

class Empty
  def depth
    0
  end
end

class Leaf
  def depth
    1
  end
end

class Node
  attr_accessor :field1, :field2

  def depth
    1 + [field1.depth, field2.depth].max
  end
end

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

Answer 2

मैं कर रहा हूँ नहीं इतना यकीन स्पष्टीकरण सब है कि उत्कृष्ट।

बीजीय डेटा प्रकारों का उपयोग डेटा संरचनाओं को बनाने के लिए किया जाता है, जैसे सूचियां और पेड़।

उदाहरण के लिए पार्स पेड़ों को आसानी से बीजीय डेटा संरचनाओं के साथ दर्शाया जाता है।

data BinOperator = Add
                 | Subtr
                 | Div
                 | Mult
                 | Mod
                 | Eq
                 | NotEq
                 | GreaterThan
                 | LogicAnd
                 | LogicOr
                 | BitAnd
                 | BitOr
                 | ...

data UnOperator = Negate
                | Not
                | Increment
                | Decrement
                | Complement
                | Ref
                | DeRef


data Expression = Empty
                | IntConst Int
                | FloatConst Float
                | StringConst String
                | Ident String
                | BinOp BinOperator Expression Expression
                | UnOp UnOperator Expression Bool //prefix or not
                | If Expression Expression Expression
                | While Expression Expression Bool //while vs. do while
                | Block List<Expression>
                | Call Expression List<Expression>
                | ...

यह वास्तव में सी भाषा का प्रतिनिधित्व करने के लिए बहुत अधिक नहीं लेगा।

लेकिन वास्तव में, आप बीजीय डेटा प्रकारों के साथ हर किसी के बारे में कर सकते हैं। लिस्प साबित होता है, आप जोड़े के साथ सब कुछ कर सकते हैं और एडीटी बस इस दृष्टिकोण के लिए एक अधिक दानेदार और सुरक्षित तरीका प्रदान करते हैं।

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

If(Call(Ident('likes_ADTs'),[Ident('you')]),
   Call(Ident('use_ADTs'),[Ident('you')]),
   Call(Ident('use_no_ADTs'),[Ident('you')]))