रिकर्सिव डेटा संरचनाओं को परिभाषित करना

Question

मैं हास्केल सीखने की कोशिश कर रहा हूं, यह सोचकर कि यह Combinatorial Game Theory को लागू करने के लिए एकदम सही भाषा होगी। मैंने कुछ हद तक पायथन में इसे ओओपी सिद्धांतों और ऑपरेटर ओवरलोडिंग को पढ़ाने के लिए किया है, लेकिन हास्केल मुझे आकर्षित करता है क्योंकि यह इसके वाक्यविन्यास में अधिक गणितीय लगता है, और गणित पृष्ठभूमि होने पर मुझे वास्तव में यह पसंद है। इसके अलावा, आलसी रूप से लागू अनंत सूचियों को बहुत अद्भुत है।

वैसे भी, क्या मैं अब तक एक डेटा संरचना है कि संकलित लेकिन पहले समारोह मैं लिखा इसे का उपयोग किया है मुझे देता है:

Prelude> :l cgt 
[1 of 1] Compiling Main    (cgt.hs, interpreted) 

cgt.hs:8:30: 
    Couldn't match expected type `([Game], b0)' with actual type `Game' 
    In the first argument of `fst', namely `b' 
    In the second argument of `(:)', namely `(fst b)' 
    In the expression: a : (fst b) 
    Failed, modules loaded: none. 

यहाँ मेरी कोड है ...

--A game that is Zero (base case) is two empties 
--Anything else must be two lists of games, a left list and a right list. 

data Game = Zero 
      | Position ([Game], [Game]) 

putL :: Game -> Game -> Game 
putL a b = Position (a :(fst b), snd b) 

मुझे एहसास है कि एक गेम कुछ हद तक पेड़ की तरह है जैसा कि Wikibook पर चर्चा की गई है, लेकिन उनके पास अतिरिक्त प्रतिबंध हैं।

1. एक स्थान (एक पेड़ नोड के लिए परिजन) कई संभावित चाल
2. हो सकता है एक स्थिति केवल अन्य खेल
3. एक विशेष खेल, शून्य नहीं है, कोई संभव चाल है कि हो सकता है।
4. सभी गेम शून्य का उपयोग करके बनाए गए हैं।

तो मैं जब लिखा putL मैं कहता हूँ, "b के पहले भाग में एक खेल a और एक अन्य खेल b, और विपक्ष a ले लो, और अकेले b के दूसरे भाग को छोड़, एक स्थिति लौटने (जो एक है तरह का खेल)। " कम से कम, यही वह है जो मैं करने की कोशिश कर रहा हूं। इसके बजाय हास्केल सोच रहा है कि जिस प्रकार मैं लौट रहा हूं वह ([Game], b0) है और मुझे नहीं पता कि क्यों।

धन्यवाद! तुम्हारी सहायता सराहनीय है।

Answer 1

आप fst और snd किसी प्रकार के Game पर फ़ंक्शंस का उपयोग नहीं कर सकते हैं। चूंकि आपने अपने डेटा कन्स्ट्रक्टर Zero और Position में अपने फ़ील्ड के लिए नाम घोषित नहीं किए हैं, इसलिए वास्तव में उन्हें एक्सेस करने का एकमात्र तरीका पैटर्न मिलान के माध्यम से है। (ध्यान दें कि मैं भी Position निर्माता में अनावश्यक टपल हटाया)

data Game 
    = Zero 
    | Position [Game] [Game] 

putL :: Game -> Game -> Game 
putL game Zero = ??? 
putL game (Position games1 games2) = Position (game : games1) games2 

अब, मैं स्पष्ट रूप से आप क्या Zero निर्माता के लिए क्या करना चाहते पता नहीं है, ताकि आप उन ??? को भरने के लिए होगा ' स्वयं

Answer 2

dflemstr का उत्तर सही है। मैं आपके द्वारा प्राप्त त्रुटि संदेश की व्याख्या करने जा रहा हूं।

• a : fst b प्रकार [Game] होना आवश्यक है --- सहमति, हाँ?
• इसलिए a प्रकार Game होना चाहिए ... (और यह करता है, हुर्रे)
• ... और fst b प्रकार होना आवश्यक है [Game]
• fst इनपुट के रूप में एक जोड़ी लेता है, और इस जोड़ी के पहले तत्व पैदावार, तो ...
• ...b प्रकार ([Game], b0) (कुछ प्रकार b0 है कि हम अभी तक बाहर काम नहीं किया के लिए) होना चाहिए (इस उम्मीद प्रकार है)
• यह एक समस्या है क्योंकि putL के लिए प्रकार हस्ताक्षर के अनुसार, b प्रकार Game होना चाहिए (इस वास्तविक प्रकार है) --- यह एक जोड़ी