नीचे दिया गया कोड लिखा है और इसके साथ कुछ समस्याएं आ रही हैं:

मुझे जो त्रुटि मिल रही है वह है: डेटा कंस्ट्रक्टर दायरे में नहीं: Int :: Int

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

नीचे कोड है और क्षमा चाहता है यदि यह प्रश्न लंबे समय से हवादार या मूर्खतापूर्ण है, तो यह स्टैक ओवरफ्लो पर मेरी पहली पोस्ट है, इसलिए इस क्यू से कैसे पूछा गया था, इस पर कोई प्रतिक्रिया भी बहुत सराहना की जाएगी।

किसी भी मदद की अत्यधिक सराहना की जाएगी

import Test.QuickCheck
import Data.Data
import Data.Typeable


data Suit = Spades | Hearts | Clubs | Diamonds
              deriving Show

data Colour = Black | Red
                deriving Show

colour :: Suit -> Colour
colour Spades = Black
colour Hearts = Red
colour Diamonds = Red
colour Clubs = Black

data Rank = Numeric Int | Jack | Queen | King | Ace
              deriving Show

rankBeats :: Rank -> Rank -> Bool
rankBeats _ Ace = False
rankBeats Ace _ = True
rankBeats _ King = False
rankBeats King _ = True
rankBeats _ Queen = False
rankBeats Queen _ = True
rankBeats _ Jack = False
rankBeats Jack _ = True
rankBeats (Numeric m) (Numeric n) = m > n

prop_rankBeats :: Rank -> Rank -> Bool
prop_rankBeats a b = rankBeats a b || rankBeats b a

instance Arbitrary Rank where
  arbitrary = elements [Numeric Int,Jack, Queen, King, Ace]
0
harleengulati03 10 अक्टूबर 2021, 18:18

1 उत्तर

सबसे बढ़िया उत्तर

Rank के लिए आपके Arbitrary इंस्टेंस में एक Int शामिल है:

instance Arbitrary Rank where
  --                      an Int ↓
  arbitrary = elements [Numeric Int, Jack, Queen, King, Ace]

लेकिन एक Int डेटा कंस्ट्रक्टर नहीं है, बल्कि एक टाइप कंस्ट्रक्टर है। आप इसका उपयोग नहीं कर सकते।

आप क्या कर सकते हैं एक जनरेटर बनाते हैं जो दिखता है:

instance Arbitrary Rank where
  arbitrary = oneof ((Numeric <$> arbitrary) : map pure [Jack, Queen, King, Ace])

यहां पहला आइटम संख्यात्मक <$> मनमाना Int प्रकार के मनमाने उदाहरण का उपयोग करेगा, और इसके अलावा हम मानचित्र का उपयोग करते हैं [ जैक, क्वीन, किंग, ऐस] इन रैंक को जनरल रैंकs में बदलने के लिए। oneof :: [Gen a] -> Gen a फिर हर बार सूची से एक यादृच्छिक जनरेटर चुनेंगे। oneof समान भार वाले आइटम चुनेंगे। उदाहरण के लिए हम इन्हें अलग-अलग वज़न के साथ चुनने के लिए फ़्रीक्वेंसी का उपयोग कर सकते हैं:

{-# LANGUAGE TupleSections #-}

instance Arbitrary Rank where
  arbitrary = frequency ((9, Numeric <$> chooseInt (2,10)) : map ((1,) . pure) [Jack, Queen, King, Ace])

यहां यह अधिक उचित है: 13 में से 9 बार, यह एक <कोड>संख्यात्मक चुनेंगे, और हम chooseInt (2, 10) का उपयोग करते हैं जैसे कि हम केवल Int उत्पन्न करते हैं s 2 और 10 के बीच।

1
Willem Van Onsem 10 अक्टूबर 2021, 18:36
बहुत - बहुत धन्यवाद। हालांकि एक मनमाना उदाहरण होने का क्या मतलब है?
 – 
harleengulati03
11 अक्टूबर 2021, 17:23
साथ ही जब आपने आवृत्ति जोड़ने का निर्णय लिया, तो आपने ऐसा क्यों किया (1,)। शुद्ध। इसका क्या मतलब है? एक बार फिर से धन्यवाद
 – 
harleengulati03
11 अक्टूबर 2021, 17:45
@ harleengulati03: pure एक मान a को Gen a में बदल देगा: एक जनरेटर जो हर बार उस मान को उत्पन्न करेगा। (1,) इसे पहले तत्व 1 के साथ 2-टुपल में लपेटें। यह आइटम का "वजन" है, यह निर्धारित करता है कि यह कितनी बार एक Jack/Queen/King/Ace उत्पन्न करेगा। उदाहरण के लिए Numeric एक Jack की तुलना में नौ गुना अधिक बार उत्पन्न होता है।
 – 
Willem Van Onsem
11 अक्टूबर 2021, 19:20
आप एक जीवन रक्षक हैं, बहुत-बहुत धन्यवाद!
 – 
harleengulati03
12 अक्टूबर 2021, 16:59