Làm thế nào để tạo danh sách lặp lại vô hạn trong Haskell?

Question

Tôi là một chàng trai C# đang cố gắng tự mình dạy Haskell từ các webcast trên Kênh 9 của Erik Meijer. Tôi bắt gặp một câu đố thú vị liên quan đến việc bỏ qua mọi thành phần 'n' của danh sách bằng cách sử dụng zip và mod.

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

Tôi đã nghĩ rằng nó có thể hiệu quả hơn (đối với danh sách hoặc luồng thực sự lớn) nếu chúng tôi có thể tránh sử dụng mod.

Tôi nghĩ về việc tạo ra một danh sách các số nguyên lặp đi lặp lại để chúng ta có thể so sánh giá trị của i với n.

repeatInts :: Int -> [Int] 

như vậy gọi repeatInts 3 lợi nhuận [1,2,3,1,2,3,1,2,3,1,2,3,..] vô cùng tận.

Vì điều này, chúng ta có thể xác định lại every như vậy:

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

Vì vậy, câu hỏi của tôi là: làm thế nào bạn sẽ thực hiện repeatInts?

Answer 1

Sử dụng cycle:

cycle :: [a] -> [a] 

cycle quan hệ một danh sách hữu hạn thành một hình tròn, hoặc tương đương, sự lặp lại vô hạn của danh sách gốc. Đó là danh tính trên danh sách vô hạn.

Bạn có thể xác định repeatInts về cycle:

*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] 

---

Đối với người hiếu, GHC thực hiện cycle với

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

Trong cách nói hoàn toàn chức năng, kỹ thuật tò mò này là biết dưới dạng buộc nút, một d nó tạo ra các cấu trúc dữ liệu tuần hoàn thay vì các cấu trúc vô hạn.

Để biết chi tiết thấy

• “Tying the Knot” trên wiki Haskell
• “Tying the knot” trong bài bình luận GHC của
• “Explanation of ‘tying the knot’” đây trên Stack Overflow
• Stack Overflow thẻ [tying-the-knot]

Answer 2

câu trả lời cuối nhưng nó cũng có thể được viết như t của anh ấy:

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