###

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

- â€œ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]`

###

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

EmoticonEmoticon