रचनात्मक-बीजगणित पैकेज का उपयोग कर एक बीजगणित मॉड्यूल को परिभाषित करना

Question

पैकेज रचनात्मक-बीजगणित आप बीजीय के उदाहरण को परिभाषित करने की अनुमति देता है मॉड्यूल (जैसे vectorial रिक्त स्थान लेकिन एक अंगूठी जहां एक क्षेत्र आवश्यक था का उपयोग करके)

{-# LANGUAGE MultiParamTypeClasses, TypeSynonymInstances #-} 
module A where 
import Algebra.Structures.Module 
import Algebra.Structures.CommutativeRing 
import Algebra.Structures.Group 

newtype A = A [(Integer,String)] 

instance Group A where 
    (A a) <+> (A b) = A $ a ++ b 
    zero = A [] 
    neg (A a) = A $ [((-k),c) | (k,c) <- a] 


instance Module Integer A where 
    r *> (A as) = A [(r <*> k,c) | (k,c) <- as] 

:

यह एक मॉड्यूल को परिभाषित करने में मेरी कोशिश है 63,210

यह द्वारा विफल रहता है:

A.hs:15:10: 
    Overlapping instances for Group A 
     arising from the superclasses of an instance declaration 
    Matching instances: 
     instance Ring a => Group a -- Defined in Algebra.Structures.Group 
     instance Group A -- Defined at A.hs:9:10-16 
    In the instance declaration for `Module Integer A' 

A.hs:15:10: 
    No instance for (Ring A) 
     arising from the superclasses of an instance declaration 
    Possible fix: add an instance declaration for (Ring A) 
    In the instance declaration for `Module Integer A' 
Failed, modules loaded: none. 

मैं बाहर टिप्पणी तो Group उदाहरण है, तो:

A.hs:16:10: 
    No instance for (Ring A) 
     arising from the superclasses of an instance declaration 
    Possible fix: add an instance declaration for (Ring A) 
    In the instance declaration for `Module Integer A' 
Failed, modules loaded: none. 

मैं Module Integer A के लिए Ring A का एक उदाहरण की आवश्यकता होती है जो मतलब नहीं है और है के रूप में इस पढ़ा कक्षा परिभाषा में आवश्यक नहीं:

class (CommutativeRing r, AbelianGroup m) => Module r m where 
    -- | Scalar multiplication. 
    (*>) :: r -> m -> m 

क्या आप इसे समझा सकते हैं?

Answer 1

पैकेज एक

instance Ring a => Group a where ... 

उदाहरण सिर a मैचों हर प्रकार अभिव्यक्ति होता है, इसलिए किसी भी अन्य प्रकार अभिव्यक्ति के साथ किसी भी घटना ओवरलैप होगा। अगर ओवरलैप वास्तव में कहीं भी उपयोग किया जाता है तो ओवरलैप केवल एक त्रुटि का कारण बनता है। अपने मॉड्यूल में आप

instance Module Integer A where 
    r *> (A as) = A [(r <*> k,c) | (k,c) <- as] 

Module वर्ग m parameter¹ पर एक AbelianGroup बाधा है में उदाहरण का उपयोग करें। इसका मतलब है Group बाधा। तो इस उदाहरण के लिए, GroupA का उदाहरण देखा जाना चाहिए। कंपाइलर दो मिलान के उदाहरण पाता है।

यह पहली रिपोर्ट की गई त्रुटि है।

अगला इसलिए है क्योंकि संकलक A के लिए AbelianGroup उदाहरण ढूंढने का प्रयास करता है। केवल उदाहरण संकलक उस बिंदु पर के बारे में जानता

instance (Group a, Ring a) => AbelianGroup a 

तो यह instance Ring A where ... खोजने की कोशिश करता है, लेकिन निश्चित रूप से वहाँ एक नहीं है। instance Group A where ... बाहर टिप्पणी की

इसके बजाय, आप जोड़ना चाहिए एक

instance AbelianGroup a 

और भी
{-# LANGUAGE #-} pragma को OverlappingInstances जोड़ने (भले ही वह एक झूठ है, हम बस इसे इस समय संकलन बनाना चाहते) ।

OverlappingInstances के साथ, सबसे विशिष्ट मिलान उदाहरण चुना जाता है, इसलिए यह वही करता है जो आप यहां चाहते हैं।

¹ वैसे, AAbelianGroup का उदाहरण नहीं है और सही नहीं हो सकता है जब तक कि [(Integer,String)] सूची में ऑर्डर अप्रासंगिक न हो।

Answer 2

यह प्रकार अप्रिय भाषा एक्सटेंशन के बिना जांचता है।

{-# LANGUAGE MultiParamTypeClasses, TypeSynonymInstances #-} 
module A where 
import Algebra.Structures.Module 
import Algebra.Structures.CommutativeRing 
import Algebra.Structures.Group 

newtype A = A [(Integer,String)] 

instance Ring A where 
    A xs <+> A ys = A (xs ++ ys) 
    neg (A a) = A $ [((-k),c) | (k,c) <- a] 
    A x <*> A y = A [b | a <- x, b <- y ] 
    one = A [] 
    zero = A [] 

instance Module Integer A where 
    r *> (A as) = A [(r <*> k,c) | (k,c) <- as] 

यह थोड़ा भ्रमित है कि <+><*> और negRing और Group में स्वतंत्र रूप से परिभाषित कर रहे हैं; वे पूरी तरह से अलग प्रतीकों हैं, लेकिन फिर उन्हें सामान्य उदाहरण में एक साथ लाया जाता है जो सभी RingsGroups बनाता है, इसलिए Ring परिभाषित किया गया है, Group परिभाषित नहीं किया जाना चाहिए, क्योंकि यह पहले से ही बोली जाती है। मुझे यकीन नहीं है कि इस प्रकार टाइप क्लास सिस्टम काम करता है लेखक द्वारा मजबूर किया जाता है। Module को Ring या इसके बजाय CommutativeRing की आवश्यकता है। CommutativeRing मूल रूप से Ring का नाम बदल रहा है; आगे कुछ भी परिभाषित नहीं किया जाना है। यह आपको हास्केल में कम्युनिटीविटी का एक अचूक दावा करने के लिए प्रतिबद्ध है। तो आपको Module उदाहरण बनाने से पहले मॉड्यूल के बाहर बोलने के लिए, "CommutativeRing कानूनों को साबित करना" माना जाता है। ध्यान दें कि ये कानून त्वरित जांच प्रस्तावों में व्यक्त किए गए हैं, इसलिए आपको इस प्रकार के लिए विशेष propMulComm और propCommutativeRing पर त्वरित जांच चलाना होगा।

के बारे में एक और शून्य क्या करना है पता नहीं है, लेकिन आप एक उपयुक्त संरचना, हो सकता है का उपयोग करके आदेश के बारे में बात पिछले प्राप्त कर सकते हैं:

import qualified Data.Set as S 

newtype B = B {getBs :: S.Set (Integer,String) } 

लेकिन newtyped होने आप भी, जैसे, को फिर से परिभाषित कर सकते हैं Eq ए के बारे में समझने के लिए, मुझे लगता है। वास्तव में आपको quickcheck प्रस्तावों को चलाने के लिए है।

---

संपादित करें: यहाँ "विफल" और विभिन्न Eq उदाहरण के लिए "ठीक" quickcheck-बयान के साथ एक साथ QuickCheck http://hpaste.org/68351 के लिए आवश्यक जोड़ा सामग्री के साथ एक संस्करण है। यह पैकेज मेरे लिए काफी उचित प्रतीत होता है; मुझे लगता है कि यदि आप रिंग और कम्यूटेटिविंग व्यवसाय नहीं चाहते हैं, तो आपको मॉड्यूल को फिर से परिभाषित करना चाहिए, क्योंकि वह कहता है कि वह केवल "कम्युनिटी केस पर विचार करें, इसके बजाय बाएं और दाएं मॉड्यूल को लागू करना संभव होगा।" अन्यथा आप क्विक चेक का उपयोग करने में सक्षम नहीं होंगे, जो स्पष्ट रूप से पैकेज का मुख्य बिंदु है, अब मैं देख रहा हूं कि क्या हो रहा है, और जिसने इसे करने के लिए अविश्वसनीय रूप से आसान बना दिया है। चूंकि यह ए बिल्कुल सही चीज है जो वह क्विक चेक के सर्वव्यापी उपयोग से बाहर निकलने की कोशिश कर रहा है, जो निश्चित रूप से इस तरह के मामले में चाल करना बहुत मुश्किल होगा।