हास्केल पहले, मध्य अनुभाग मिलान पैटर्न, और पिछले

Question

तो मैं हास्केल

में एक साधारण स्ट्रिंग रिवर्स समारोह करना चाहता था

swapReverse :: String => String 
swapReverse [x] = [x] 
swapReverse [x,y] = [y,x] 
swapReverse (x:xs:l) =   -- pattern match fails here 
    let last = [l] 
     middle = xs 
     first = [x] 
    in last ++ swapReverse middle ++ first 

तो वहाँ Haskell है कि first और last में एक पैटर्न संरचना को परिभाषित करने के लिए एक रास्ता है तत्व, और middle में सभी तत्व?

Answer 1

नहीं, आप नहीं कर सकते। क्यूं कर? चूंकि पैटर्न मिलान मूल्यों और उनके उप-समूह से मेल खाता है, लेकिन सूची का "मध्य" सूची का उप-भाग नहीं है। इसकी संरचना के संदर्भ में सूची [1, 2, 3, 4]1:(2:(3:(4:[]))) है। तो आप first से 1 और last से 4 से मिलान करना चाहते हैं, जो सूची के दोनों उपपर हैं, और इस प्रकार अयोग्य नहीं हैं। लेकिन middle जो आप चाहते हैं 2:(3:[]) होगा, जो सूची का उप-समूह नहीं है, और इस प्रकार, कोई मिलान नहीं हो सकता है।

ध्यान दें कि हम एक साथ सूची के पहले और अंतिम तत्वों को मिलान करने के लिए एक पैटर्न नहीं लिख सकते हैं, या तो। एक पैटर्न में गहराई होती है जो संकलन समय पर तय होती है।

Answer 2

पैटर्न मिलान कंस्ट्रक्टर्स पर काम करता है, : तो आप सूची के बीच में मेल नहीं खा सकता केवल सूची निर्माता है। आपको पीछे की नई सूची (स्पष्ट रूप से :)) बनाने की ज़रूरत है, जिसे सिर लेकर और बाकी सूची के विपरीत में जोड़कर किया जा सकता है।

Answer 3

इस कोड का प्रयास करें:

last1 (x:xs:l) = (x,xs,l) 

l आप एक सूची में अंतिम तत्व नहीं मिलता है, तो यह आपको पहले दो चर, जिसमें पहले दो तत्वों आवंटित कर रहे हैं के अलावा सूची में से बाकी है मिल एक सूचि।

जब आप किसी सूची के लिए पैटर्न मिलान लिखते हैं, तो पहले चर को पहला तत्व असाइन किया जाता है, और इसी तरह, जब तक कि प्रोग्राम अंतिम चर तक नहीं पहुंच जाता है, जहां शेष सबकुछ शेष होता है। x के बाद s जोड़ने के बारे में कुछ भी खास नहीं है, y नामक एक चर एक ही काम करेगा।

आप एक सूची के अंतिम तत्व प्राप्त करना चाहते हैं, तो आप एक पैटर्न (x:xs) के समान बनाने के लिए, और xs पर प्रत्यावर्तन का उपयोग करें और उस पैटर्न लागू जब तक आप एक सूची तत्व, जो पिछले तत्व है करने के लिए नीचे पाने की जरूरत है। हालांकि, मैं एक सूची को वापस करने के बेहतर तरीके के लिए Adam Bergmark's उत्तर पढ़ने की अनुशंसा करता हूं जिसमें सूची के पहले और अंतिम तत्वों को शामिल नहीं किया गया है।

Answer 4

एक कार्यरत वर्शन:

swapReverse :: String -> String 
swapReverse (x:xs) = [last xs] ++ swapReverse (init xs) ++ [x] 
swapReverse xs = xs 

नोट एक आपदा है कि इस कार्यान्वयन प्रदर्शन के लिहाज से। एक गुना और/या accumulators का उपयोग कर कार्यान्वयन अधिक कुशल हैं।