2014-09-26 5 views
7

मैं कार्यात्मक प्रोग्रामिंग के लिए अपना परिचय पूरा करने के लिए कल एक परीक्षण के लिए प्रशिक्षण दे रहा हूं लेकिन एक बात है जिसे मैं समझ नहीं पा रहा हूं।हास्केल: गैर-संपूर्ण पैटर्न

जब भी मैं की तरह एक कार्यक्रम है:

test [] = [] 
test (x:xs) = test (xs) 

क्या वह करता है कि वह सूची से बाहर पहला तत्व लेता है और बाकी के साथ जारी है। जब भी कोई बाएं होता है, xs[] होना चाहिए जो बदले में test [] = [] को ट्रिगर करना चाहिए। लेकिन जब भी मैं इस एल्गोरिदम को चलाता हूं तो मुझे एक त्रुटि मिलती है। Exception: <interactive>:20:5-16: Non-exhaustive patterns in function test.

मुझे ऑनलाइन स्पष्ट स्पष्टीकरण नहीं मिला। क्या कोई मुझे एक लिंक भेज सकता है जहां इसे स्पष्ट रूप से समझाया गया हो या मुझे समझाया जाए?

+1

अजीब। आपके द्वारा पोस्ट किए गए कोड स्निपेट में गैर-संपूर्ण पैटर्न नहीं हैं। – pyon

+1

बस अंधेरे में शूटिंग: क्या आप शायद इस परिभाषा को ghci में दर्ज करने की कोशिश कर रहे हैं? यदि ऐसा है, तो आपको एक ही बयान कथन का उपयोग करना चाहिए: 'परीक्षण करें [] = []; परीक्षण (एक्स: एक्सएस) = परीक्षण xs'। – pyon

+0

हां, यही वह है जो मैं कर रहा हूं। बहुत बहुत धन्यवाद। मैंने पहले से ही बाहर निकलना शुरू कर दिया क्योंकि मैंने इस पूरे सप्ताह प्रोग्रामिंग रिकर्सन बिताए और मुझे पता नहीं चला कि यह क्यों काम नहीं करेगा। –

उत्तर

24

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

Prelude> let test [] = [] ; test (x:xs) = test xs 

क्या आप here कर रहे हैं वह सही नहीं है: हालांकि, अगर आप GHCi में इस परिभाषा में प्रवेश करने की कोशिश करते हैं, आप एक एकलlet बयान का उपयोग करना चाहिए। आपको सबसे पहले एक गैर संपूर्ण समारोह test परिभाषित कर रहे हैं:

Prelude> let test [] = [] 

और फिर आप परिभाषित कर रहे हैं एक और गैर संपूर्ण समारोह, भी test कहा जाता है, जो खाल पहले एक:

Prelude> let test (x:xs) = test xs 
+1

मेरी इच्छा है कि मैं इसे और अधिक बार बढ़ा सकता हूं। –

4

यह वह जगह है वास्तव में हास्केल के आरईपीएल (जीएचसीआई) में शिशु कार्यक्रमों की कोशिश करने के बारे में एक बहुत ही मुश्किल बात है।

let का उपयोग करना बहुत स्पष्ट नहीं है (esp।, क्योंकि इसे एक अलग 'स्क्रिप्ट/प्रोग्राम' में आवश्यक नहीं है)।

और कभी-कभी हम एक पूर्ण फ़ाइल नहीं बनाना चाहते हैं बल्कि इसके बजाय विभिन्न मामलों के साथ एक छोटे से फ़ंक्शन के साथ प्रयोग करना चाहते हैं।

हमारे कार्य की सीमा को परिभाषित करने के लिए delimiters :{ & :} का उपयोग करने का एक और सहायक तरीका है।

कहें कि हम एक साधारण रिकर्सिव sum फ़ंक्शन का प्रयास करना चाहते हैं जो संख्याओं की एक सूची जोड़ सकता है। हम तो कहेंगे निम्नलिखित:

λ > :{ 
Prelude| sum [] = 0 
Prelude| sum (x:xs) = x + sum xs 
Prelude| :} 
sum :: Num t => [t] -> t 
Prelude 
λ > sum [1..10] 
55 
it :: (Enum t, Num t) => t 

नोट कैसे अच्छी तरह से हम अपने समारोह की हद तक देखने को मिलता है!

उम्मीद है कि इससे मदद मिलती है। चीयर्स!

संबंधित मुद्दे