हास्केल में असीमित दोहराने वाली सूची कैसे बनाएं?

Question

मैं एक सी # लड़का हूं जो खुद को एरिक मीजर के चैनल 9 वेबकास्ट से हास्केल सिखाने की कोशिश कर रहा है। मैं एक दिलचस्प पहेली में आया जिसमें ज़िप और मॉड का उपयोग करके सूची के प्रत्येक 'एन' तत्वों को छोड़ना शामिल था।

every :: Int -> [a] -> [a] 
every _ [] = [] 
every n xs = [x | (x,i) <- zip xs [1..], i `mod` n == 0] 

मैं सोच रहा है यह (बहुत बड़ी सूची, या नदियों के लिए) और अधिक कुशल अगर हम आधुनिक का उपयोग कर से बचने के सकता है हो सकता है।

मैंने आलसी की दोहराई गई सूची बनाने के बारे में सोचा था ताकि हम आसानी से i से n के मूल्य की तुलना कर सकें।

repeatInts :: Int -> [Int] 

ऐसी है कि फोन करने repeatInts 3 रिटर्न [1,2,3,1,2,3,1,2,3,1,2,3,..] अनंत तक। मेरे सवालों का

every :: Int -> [a] -> [a] 
every _ [] = [] 
every n xs = [x | (x,i) <- zip xs (repeatInts n), i == n] 

तो है::

इस देखते हुए, हम every इसलिए की तरह फिर से परिभाषित कर सकता है कि कैसे आप repeatInts लागू होगा?

Answer 1

उपयोग cycle: एक परिपत्र में

cycle :: [a] -> [a] 

cycle संबंधों एक परिमित सूची, या समतुल्य मूल सूची के अनंत पुनरावृत्ति। यह अनंत सूचियों पर पहचान है।

आप cycle के मामले में repeatInts निर्धारित कर सकते हैं:

*Main> let repeatInts n = cycle [1..n] 
*Main> :t repeatInts 
repeatInts :: (Num t, Enum t) => t -> [t] 
*Main> take 10 $ repeatInts 3 
[1,2,3,1,2,3,1,2,3,1] 

---

उत्सुक के लिए, GHC लागू करता cycle

cycle [] = errorEmptyList "cycle" 
cycle xs = xs' where xs' = xs ++ xs' 

पूरी तरह कार्यात्मक की भाषा में साथ, इस उत्सुक तकनीक जाना जाता है गाँठ बांधकर, एक डी यह अनंत लोगों की बजाय चक्रीय डेटा संरचनाओं बनाता है।

विवरण हास्केल विकी पर देखने

• “Tying the Knot” लिए
• GHC की कमेंट्री में “Tying the knot”
• “Explanation of ‘tying the knot’” यहाँ स्टैक ओवरफ़्लो पर
• स्टैक ओवरफ़्लो टैग [tying-the-knot]

Answer 2

देर जवाब लेकिन यह टी की तरह भी लिखा जा सकता है उसका:

repeatInts :: Int -> [Int] 
repeatInts 0 = [] 
repeatInts a = [1..a] ++ repeatInts a