How to create infinitely repeating list in Haskell?
haskell, lazy-evaluation, list
Solution
Use `cycle`:
cycle :: [a] -> [a]
`cycle` ties a finite list into a circular one, or equivalently, the infinite repetition of the original list. It is the identity on infinite lists.
You could define `repeatInts` in terms of `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]
For the curious, GHC implements `cycle` with
cycle [] = errorEmptyList "cycle"
cycle xs = xs' where xs' = xs ++ xs'
In purely functional parlance, this curious technique is known as tying the knot, and it creates cyclic data structures rather than infinite ones.
For details see
- “Tying the Knot” on the Haskell wiki
- “Tying the knot” in GHC’s commentary
- “Explanation of ‘tying the knot’” here on Stack Overflow
- Stack Overflow tag `[tying-the-knot]`
Problem
I'm a C# guy trying to teach myself Haskell from Erik Meijer's Channel 9 webcasts. I came across an interesting puzzle which involved skipping every 'n' elements of a list using zip and mod. ``` every :: Int -> [a] -> [a] every _ [] = [] every n xs = [x | (x,i) <- zip xs [1..], i `mod` n == 0] ``` I've been thinking it might be more efficient (for really large lists, or streams) if we could avoid using mod. I thought about lazily creating a repeating list of integers so we can simply compare the value of i to n. ``` repeatInts :: Int -> [Int] ``` such that calling `repeatInts 3` returns `[1,2,3,1,2,3,1,2,3,1,2,3,..]` ad infinitum. Given this, we could redefine `every` like so: ``` every :: Int -> [a] -> [a] every _ [] = [] every n xs = [x | (x,i) <- zip xs (repeatInts n), i == n] ``` So my questions is: how would you implement `repeatInts`?