ईक टाइपक्लास

Question

डालने वाला मैं आवेदन की तरह एक सीआरयूडी लिख रहा हूं और प्राथमिक कुंजी (प्राथमिक कुंजी के विभिन्न प्रकार हो सकते हैं) द्वारा बहुत सारे लुकअप हैं। इसलिए मैं typeclass निम्नलिखित परिभाषित:

{-# LANGUAGE MultiParamTypeClasses #-} 

class Eq b => HasPK a b where 
    getPK :: a -> b 

अब मैं लिख सकते हैं:

import Data.Maybe 

lookupPK :: HasPK a b => b -> [a] -> Maybe a 
lookupPK s = listToMaybe . filter ((== s) . getPK) 

अब, जब मैं पी के साथ दो बातें की तुलना करना चाहते हैं, मैं सिर्फ अपने पी के तुलना करना चाहते हैं। तो, मैं इस परिभाषित करने के लिए कोशिश कर रहा हूँ:

{-# LANGUAGE FlexibleInstances #-} 
{-# LANGUAGE UndecidableInstances #-} 

instance (HasPK a b) => Eq a where 
    (==) = (==) `on` getPK 

लेकिन अब यह मुझे देता है:

src/Utils.hs:61:10: Could not deduce (HasPK a b0) … 
     arising from the ambiguity check for an instance declaration 
    from the context (HasPK a b) 
     bound by an instance declaration: HasPK a b => Eq a 
     at /home/utdemir/workspace/.../Utils.hs:61:10-28 
    The type variable ‘b0’ is ambiguous 
    In the ambiguity check for: forall a b. HasPK a b => Eq a 
    To defer the ambiguity check to use sites, enable AllowAmbiguousTypes 
    In the instance declaration for ‘Eq a’ 
Compilation failed. 

किसी को भी व्याख्या कर सकते हैं इस त्रुटि मेरे लिए? क्या मैं सही रास्ते पर हूं, या क्या मैं चाहता हूं कि हासिल करने का एक सुरक्षित तरीका है?

Answer 1

आप की जरूरत है यहाँ एक कार्यात्मक निर्भरता:

class Eq b => HasPK a b | a -> b where 
    getPK :: a -> b 

का उपयोग करें और के लिए जो कुछ भी विस्तार GHC अंक सक्षम करें। के बाद से ऊपर डबल उदाहरण जोड़ा जा सकता है

मुद्दा,

instance HasPK MyType Int where ... 
instance HasPK MyType String where ... 

में के रूप में एक ही प्रकार के लिए कई पीकेएस होने की संभावना में निहित है बाद में, (==) `on` getPK की तरह कोड संभावित अस्पष्ट है। दरअसल, जब ऊपर दिए गए उदाहरण जोड़े जाते हैं, तो यह निर्दिष्ट नहीं करता है कि Int पीके या String एक का उपयोग करना है या नहीं।

---

हालांकि, जैसे

instance (HasPK a b) => Eq a where 
    ... 

एक उदाहरण है, क्योंकि यह किसी भी अन्य Eq उदाहरण के साथ ओवरलैप हो, समस्याएं पैदा होने की संभावना है। यहां सावधान रहें। मैं बजाय

equalPK :: HasPK a b => a -> a -> Bool 
equalPK = (==) `on` getPK 

लिखना और फिर इस रूप में सभी प्रासंगिक प्रकार के स्पष्ट उदाहरण हैं प्रदान करेगा:

instance Eq MyType1 where (==) = equalPK 
instance Eq MyType2 where (==) = equalPK 
... 

---

एक और विकल्प के रूप में, आप

class HasPK a where 
    type PK a 
    getPK :: a -> PK a 

equalPK :: Eq (PK a) => a -> a -> Bool 
equalPK = (==) `on` getPK 

instance Eq MyType1 where (==) = equalPK 
... 

के रूप में एक प्रकार परिवार में इस तरह उपयोग कर सकते हैं