हास्केल स्टार्टर प्रश्न ... कृपया मुझे यह बताएं

Question

मुझे कुछ हैकेल प्रोग्राम लिखना है, लेकिन मुझे नहीं पता कि कहां से शुरू करना है। यदि आप मुझे प्रश्न पढ़ने या समझाने के लिए कुछ संसाधनों के बारे में बता सकते हैं तो मैं वास्तव में वास्तव में आभारी रहूंगा। मुझे यकीन है कि यह पूरी तरह शौकिया है, लेकिन मुझे वास्तव में एक शुरुआती बिंदु चाहिए।

data DFA q o    = DFA (q -> o -> q) q [q] 
data NFA q o    = NFA (q -> o -> [q]) [q] [q] 
-- I really realy don't understand the declarations here 
-- I can guess that q is somewhat related to Q and o to E, but don't get what it really means 

data Q      = Q0 | Q1 | Q2 
           deriving (Eq, Enum, Bounded) 

data E      = A | B 


-- what does n1 do ?? 
n1       :: NFA Q E 
n1       = NFA d [Q0] [Q2] -- i see [Q0] refers to set of initial states and [Q2] refers to final states :) 
           where 
            d Q0 A = [Q0] 
            d Q0 B = [Q0, Q1] 
            d Q1 _ = [Q2] 
            d Q2 _ = [] 


-- the following functions are for me to write 
starDFA :: Eq q => DFA q o -> [o] -> Bool 
--for the above function, what are the arguments the function takes in ? 
--how can we relate q with Q and [o] with [E] ?? 

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

धन्यवाद

Answer 1

Learn You a Haskell for Great Good! शायद इस समय सबसे अच्छा हास्केल ट्यूटोरियल है। मैं पूरी चीज के माध्यम से पढ़ने की सलाह देता हूं, लेकिन यदि आप जल्दी में हैं, तो मैं इस असाइनमेंट के लिए कुछ अधिक प्रासंगिक अनुभागों को इंगित करूंगा।

कोड आप दिया जाता है में मुख्य हिस्सा है, data घोषणाओं हैं, इसलिए एक बार आप मूल बातें (chapter 2 और first section of chapter 3) से परिचित हैं, में गोता लगाने के लिए एक अच्छी जगह Algebraic data types intro, Type variables और Type parameters है।

उपरोक्त डेटा घोषणाओं का गूढ़ रहस्य और बनाम Q और o बनाम Eq बीच संबंधों को समझने के लिए पर्याप्त होना चाहिए।

अब वास्तविक कार्य को लागू करने के लिए, आपको deterministic finite automata कार्य से परिचित होना चाहिए और फिर वास्तविक कार्यान्वयन लिखने के लिए पर्याप्त हास्केल को जानना आवश्यक है। Chapter 4 और chapter 5 ट्यूटोरियल में इसके लिए सबसे प्रासंगिक अध्याय हैं और आपको section on standard library list functions उपयोगी भी मिल सकता है।

एक बार जब आप इस बिंदु पर पहुंच जाते हैं, तो यदि आप कार्यान्वयन के साथ फंस गए हैं, तो आप अब तक लिखे गए कोड के साथ एक और प्रश्न पोस्ट कर सकते हैं।

Answer 2

थोड़ा मैं हास्केल प्रकार घोषणाओं के बारे में समझने से, के बारे में DFA और NFA की तरह कुछ (NFA को देख, उदाहरण के लिए) कह रहे हैं प्रारंभिक बयान:

(बाएं हाथ की ओर :) NFA एक प्रकार है कि दो का इस्तेमाल करता है इसके निर्माण में प्रकार (क्यू और ओ)।

(दायां हाथ की ओर :) एनएफए का एक उदाहरण एनएफए कहा जाएगा, और तीन पैरामीटर से बना होगा:
(1) "(q -> o -> [q])", जिसका मतलब है कि एक कार्य पैरामीटर, टाइप क्यू में से एक और टाइप ओ में से एक है, और q की सूची देता है, ([q])
(2) "[q]", जिसका अर्थ है q
(3) "के मानों की एक सूची क्यू] ", प्रकार q के मूल्यों का एक और सूची

n1 NFA का एक उदाहरण निर्माण की तरह लगता है, और हम

n1       = NFA d [Q0] [Q2] 

देखना 0

तो हम अनुमान लगा सकते हैं कि:
(1) डी एक ऐसा फ़ंक्शन है जो दो पैरामीटर, 'क्यू' और 'ओ' लेता है और क्यू के
(2) [Q0] की एक सूची देता है क्यू, और
(3) [क्यू 2] क्यू की एक सूची है।

और, वास्तव में, घ की परिभाषा इस प्रकार है:
घ दो पैरामीटर, एक 'क्यू' और एक 'ई' लेता है और क्यू के की एक सूची देता है (जो हम जानते हैं हो सकता है या तो Q0, Q1, या Q2) या एक खाली सूची।

मुझे उम्मीद है कि थोड़ा और/या शायद कोई मेरी मदद कर सकता है और मेरी अस्पष्ट समझ को भी सही कर सकता है।

Answer 3

हास्केल में हम तीन तरह से नए प्रकार परिभाषित करने के लिए है, तीन अलग कीवर्ड, प्रकार, newtype, और डेटा का उपयोग कर।

आपके उदाहरण में यह डेटा कीवर्ड उपयोग में है, चलो इस पर थोड़ा और ध्यान दें।
यह अपने कोड

data E = A | B 

यहाँ से आने वाले सबसे आसान एक के साथ शुरू करने के लिए बेहतर है, हम एक नए प्रकार के ई जो केवल दो मोड या राज्य या मूल्य ले जा सकते हैं परिभाषित किया है।
ऐसा एक प्रकार है जिसे हम योग प्रकार कहते हैं। हम इसका उपयोग कैसे कर सकते हैं?
अधिकतर पैटर्न मिलान के साथ।

useE :: E -> String 
useE A = "This is A" 
useE B = "This is B" 

अब, आपके कोड से एक अधिक जटिल डेटा घोषणा।

data Q = Q0 | Q1 | Q2 deriving (Eq, Enum, Bounded) 

फिर, जैसा कि पहले कहा कि हम एक योग प्रकार जो एक नए प्रकार के प्रश्न को परिभाषित, ले लिया तीन मूल्य, Q0, Q1 या Q2 की है। लेकिन हमारे पास क्लॉज प्राप्त करने वाला है, जो संकलक को बताता है कि यह नया प्रकार ईक, एनम, बाउंड क्लास से प्राप्त विधि (या फ़ंक्शन) को प्राप्त करने (या विरासत) को लागू करता है। इसका क्या अर्थ है?
चलिए एक फ़ंक्शन पर नज़र डालें।
कल्पना कीजिए कि आप क्यू के प्रत्येक मूल्य के लिए एक संख्या को जोड़ना चाहते हैं, हम इसे कैसे कर सकते हैं?

enumQ :: Q -> Int 
enumQ x = fromEnum x 

आप इस विशेष कार्यक्षमता के बारे में और अधिक जानकारी, खंड पाने द्वारा प्रदान संसाधनों जो संकेत दिया है पढ़ सकते हैं और कोशिश करना चाहते हैं: GHCi के तहत जानकारी Enum। ध्यान दें कि पिछला प्रकार उसी वर्ग से भी प्राप्त हो सकता है। चूंकि इन प्रकारों को पूरी तरह से मान के एक मूल्यवान सेट के योग के रूप में वर्णित किया गया है (द्वारा भेदभावित) हम बेहतर समझते हैं कि हम उन्हें योग प्रकार क्यों कहते हैं।

अंततः सबसे कठिन डेटा घोषणा।

data DFA q o = DFA (q -> o -> q) q [q] 
data NFA q o = NFA (q -> o -> [q]) [q] [q] 

वे लगभग एक ही डेटा परिभाषा हैं तथ्य यह है तो मैं पहले एक गर्त जाने के लिए और आप एक व्यायाम के रूप दूसरा एक के विश्लेषण करने देगा।

data DFA q o = DFA (q -> o -> q) q [q] 

इस बार हम के बारे में डेटा निर्माता और प्रकार निर्माता बात करना चाहिए।

• समानता के बाएं हाथ की तरफ, डेटा निर्माता, बनाया आंकड़ों के और यह एक नाम देना है। इस तरफ हमारे पास इस नए डेटा को बनाने के लिए आवश्यक पैरामीटर आवश्यक है।
• समानता के दाईं ओर, प्रकार का निर्माता, इस नए प्रकार का निर्माण किया गया है। इस तरफ हमारे पास स्पष्ट प्लम्बरिंग है जो पाठक को दिखाती है कि मौजूदा प्रकार का उपयोग करके यह नया प्रकार (डेटा) बनाया गया है।

अब ध्यान में रखते हुए, जो निम्न, प्रकार के होते हैं

• [x] ::: प्रकार बहुरूपी सूची, उदाहरण के लिए, [इंट] => इंट
की सूची का प्रतिनिधित्व
• एक्स ::: एक बुनियादी प्रकार, मौजूदा एक में से एक (इंट, चार, स्ट्रिंग ...)
• एक्स -> y ::: प्रकार जो एक समारोह लिया एक प्रकार एक्स परिभाषित ठेस यूसी टाइप वाई।
• x -> y -> z ::: टाइप प्रकार को उत्पन्न करने के लिए एक प्रकार x और टाइप वाई को टाइप करें। जिसे एक प्रकार के फ़ंक्शन के रूप में देखा जा सकता है (x-> y) और एक प्रकार जेड उत्पन्न करना। यही वह है जिसे हम हाई-ऑर्डर फ़ंक्शन कहते हैं।

तो हमारे डेटा घोषणा, इस संदर्भ में डाल दिया, एक डेटा निर्माता, ओ और एक परिणाम के रूप में दो प्रकार पैरामीटर, क्ष और द्वारा फ़ीड है, इसके बारे में उत्पाद के रूप में एक नए प्रकार वापसी एक उच्च क्रम कार्य एक मूल प्रकार और एक सूची प्रकार। जो बताता है कि हम इसे उत्पाद प्रकार क्यों कहते हैं।

यह आपके प्रश्न का उत्तर देने के लिए पर्याप्त हो सकता है, अब एन 1 क्या करता है?

शुभकामनाएं।