# [Haskell-cafe] Odd list comprehension behaviour

Kiss Csongor kiss.csongor.kiss at gmail.com
Thu Mar 17 03:10:52 UTC 2016

```The syntax [a, b..c] in general produces a list which starts with “a", followed by “b", going
up until reaching (possibly including) c in step sizes of (b - a).
(For simplicity’s sake, I only described non-decreasing lists)

So it is logical that a step size of 0 produces an infinite list, when [1,1..1] is given.
Notice that [1,1..1] is not the same as [1..], but "repeat 1”.

Csongor

> On 17 Mar 2016, at 02:58, Krisztian Pinter <pin.terminator at gmail.com> wrote:
>
> Hello,
>
> I noticed some odd behaviour with list comprehensions.
>
> [1..1] == [1]
> BUT
> [1,1..1] == [1..]
>
> I noticed this while writing a Clean program, but it seems Haskell inherited this as well.
> In the case of integer lists with step size >= 0 the up_list function[1] is used:
>
> up_list :: Integer -> Integer -> Integer -> [Integer]
> up_list x0 delta lim = go (x0 :: Integer)
>                     where
>                         go x | x > lim   = []
>                              | otherwise = x : go (x+delta)
>
> In the case of [1,1..1] x0 == lim, so go will recurse infinitely, producing an infinite list.
>
> I think the reasonable behaviour would be [1,1..1] == [1]. Is there a reason it doesn't work like this?
>
>
> Thanks,
> Krisztián
> _______________________________________________