विस्तार प्रोपोज़िशनल तर्क हास्केल

Question

में तर्क मोडल को

मैं प्रोपोज़िशनल तर्क मॉडलिंग के लिए हास्केल में कुछ कोड लिखा है

data Formula = Prop {propName :: String} 
      | Neg Formula 
      | Conj Formula Formula 
      | Disj Formula Formula 
      | Impl Formula Formula 
      | BiImpl Formula Formula 
    deriving (Eq,Ord) 

हालांकि, वहाँ के बाद से डेटा प्रकार बंद कर दिया है, मोडल तर्क को यह विस्तार करने के लिए कोई प्राकृतिक तरीका है। इसलिए, मैंने सोचा कि मुझे इसके बजाय कक्षाओं का उपयोग करना चाहिए। इस तरह, मैं बाद में विभिन्न मॉड्यूल में आसानी से नई भाषा सुविधाओं को जोड़ सकता हूं। समस्या यह है कि मुझे बिल्कुल नहीं पता कि इसे कैसे लिखना है। मुझे कुछ

type PropValue = (String,Bool) -- for example ("p",True) states that proposition p is true 
type Valuation = [PropValue]  

class Formula a where 
    evaluate :: a -> Valuation -> Bool 

data Proposition = Prop String 

instance Formula Proposition where 
    evaluate (Prop s) val = (s,True) `elem` val 

data Conjunction = Conj Formula Formula -- illegal syntax 

instance Formula Conjunction where 
    evaluate (Conj φ ψ) v = evaluate φ v && evaluate ψ v 

कुछ की तरह कुछ की तरह संयोजन की परिभाषा है। हालांकि, यह मेरे लिए अस्पष्ट है कि मैं इसे कैसे लिख सकता हूं ताकि यह काम करे।

Answer 1

यह काम करना चाहिए:

data Conjunction f = Conj f f 

instance Formula f => Formula (Conjunction f) where 
    evaluate (Conj φ ψ) v = evaluate φ v && evaluate ψ v 

हालांकि, मैं नहीं कर रहा हूँ यकीन है कि प्रकार कक्षाएं आप क्या हासिल करने की कोशिश कर रहे हैं के लिए सही उपकरण है।

---

शायद तुम स्पष्ट प्रकार स्तर functors का उपयोग कर और उन पर आवर्ती एक बार आज़माएंगे सकता है:

-- functor for plain formulae 
data FormulaF f = Prop {propName :: String} 
      | Neg f 
      | Conj f f 
      | Disj f f 
      | Impl f f 
      | BiImpl f f 

-- plain formula 
newtype Formula = F {unF :: FormulaF Formula} 

-- functor adding a modality 
data ModalF f = Plain f 
      | MyModality f 
-- modal formula 
newtype Modal = M {unM :: ModalF Modal} 

हाँ, यह नहीं बहुत सुविधाजनक है क्योंकि इस तरह के F,M,Plain रूप कंस्ट्रक्टर तरह से कभी कभी मिलता है। लेकिन, प्रकार वर्गों के विपरीत, आप यहां मिलान पैटर्न का उपयोग कर सकते हैं।

---

एक और विकल्प के रूप में, एक GADT का उपयोग करें:

data Plain 
data Mod 
data Formula t where 
    Prop {propName :: String} :: Formula t 
    Neg :: Formula t -> Formula t 
    Conj :: Formula t -> Formula t -> Formula t 
    Disj :: Formula t -> Formula t -> Formula t 
    Impl :: Formula t -> Formula t -> Formula t 
    BiImpl :: Formula t -> Formula t -> Formula t 
    MyModality :: Formula Mod -> Formula Mod 

type PlainFormula = Formula Plain 
type ModalFormula = Formula Mod