Tutorial :How to create infinitely repeating list in Haskell?


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?


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


Late answer but it can also be written like this:

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

Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
Next Post »