Tutorial :How to create infinitely repeating list in Haskell? Question:

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`?

Solution:1

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

Solution:2

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
Previous
Next Post »