मुझे हास्केल में केली टेबल को कैसे कार्यान्वित करना चाहिए?

Question

मुझे Cayley Table का उपयोग करने के लिए कुछ कम्प्यूटेशनल टूल को सामान्यीकृत करने में दिलचस्पी है, जिसका अर्थ है लुकअप टेबल आधारित गुणात्मक ऑपरेशन।

मैं इस प्रकार एक न्यूनतम कार्यान्वयन बना सकते हैं:

date CayleyTable = CayleyTable { 
    ct_name :: ByteString, 
    ct_products :: V.Vector (V.Vector Int) 
} deriving (Read, Show) 

instance Eq (CayleyTable) where 
(==) a b = ct_name a == ct_name b 

data CTElement = CTElement { 
    ct_cayleytable :: CayleyTable, 
    ct_index :: !Int 
} 

instance Eq (CTElement) where 
(==) a b = assert (ct_cayleytable a == ct_cayleytable b) $ 
      ct_index a == ct_index b 

instance Show (CTElement) where 
    show = ("CTElement" ++) . show . ctp_index 

a **** b = assert (ct_cayleytable a == ct_cayleytable b) $ 
      ((ct_cayleytable a) ! a) ! b 

वहाँ रन टाइम प्रकार ByteString तुलना के माध्यम से जाँच के साथ शुरू है, लेकिन तथ्य यह है कि read के लिए नहीं किया जा सकता है शामिल है, इस दृष्टिकोण के साथ हालांकि कई समस्याएं हैं सही ढंग से काम करें। कोई विचार है कि मुझे इसे सही तरीके से कैसे करना चाहिए?

मैं एक CTElement typeclass कि गुणा प्रदान करता है और उनके प्रकार स्थिरता की पुष्टि करता है, जब आईओ कर छोड़कर साथ Int के लिए newtypes CTElement1, CTElement2, आदि के एक परिवार बनाने की कल्पना कर सकते।

आदर्श रूप में, वहाँ के आसपास इस ct_cayleytable सूचक की केवल एक प्रतिलिपि गुजर भी, शायद ?cayleytable की तरह एक अंतर्निहित पैरामीटर का उपयोग करने के लिए कुछ चाल हो सकता है, लेकिन यह अच्छी तरह से कई असंगत केली तालिकाओं के साथ अदा नहीं करता है और आम तौर पर अप्रिय हो जाता है।

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

Answer 1

आपको यह समझने की आवश्यकता है कि हास्केल का प्रकार चेकर केवल प्रकारों की जांच करता है। तो आपके कैलीटेबल को एक कक्षा होने की जरूरत है।

class CaleyGroup g where 
caleyTable :: g -> CaleyTable 
... -- Any operations you cannot implement soley by knowing the caley table 

data CayleyTable = CayleyTable { 
... 
} deriving (Read, Show) 

यदि कैलीटेबल संकलन समय पर ज्ञात नहीं है तो आपको रैंक -2 प्रकारों का उपयोग करना होगा। चूंकि शिकायतकर्ता को इनवेरिएंट को लागू करने की आवश्यकता होती है, जब आपका कोड इसका उपयोग करता है, तब कैलीटेबल मौजूद है।

manipWithCaleyTable :: Integral i => CaleyTable -> i -> (forall g. CaleyGroup g => g -> g) -> a 

उदाहरण के लिए कार्यान्वित किया जा सकता है। यह आपको कैलीटेबल पर समूह संचालन करने की अनुमति देता है। यह i और CaleyTable के संयोजन से काम करता है ताकि यह एक नया प्रकार बन सके जो इसे अपने तीसरे तर्क में भेजता है।